diff --git a/libcudacxx/include/cuda/std/inplace_vector b/libcudacxx/include/cuda/std/inplace_vector
index f88f3ed80e..ff5567b30e 100644
--- a/libcudacxx/include/cuda/std/inplace_vector
+++ b/libcudacxx/include/cuda/std/inplace_vector
@@ -219,6 +219,7 @@ struct __inplace_vector_destruct_base<_Tp, _Capacity, __inplace_vector_specializ
   {}
 };
 
+// Specialization for non-trivial types. Nothing in here can be constexpr
 template <class _Tp,
           size_t _Capacity,
           __inplace_vector_specialization _Spec = __select_inplace_vector_specialization<_Tp, _Capacity>()>
@@ -249,8 +250,7 @@ struct __inplace_vector_base : __inplace_vector_destruct_base<_Tp, _Capacity, _S
   _LIBCUDACXX_INLINE_VISIBILITY __inplace_vector_base& operator=(const __inplace_vector_base& __other) noexcept(
     _CCCL_TRAIT(is_nothrow_copy_constructible, _Tp) && _CCCL_TRAIT(is_nothrow_copy_assignable, _Tp))
   {
-    const auto __diff = static_cast<ptrdiff_t>(__other.size() - size());
-    if (__diff < 0)
+    if (__other.size() < size())
     {
       const auto __new_end = _CUDA_VSTD::copy(__other.begin(), __other.end(), begin());
       __destroy(__new_end, end());
@@ -266,8 +266,7 @@ struct __inplace_vector_base : __inplace_vector_destruct_base<_Tp, _Capacity, _S
   _LIBCUDACXX_INLINE_VISIBILITY __inplace_vector_base& operator=(__inplace_vector_base&& __other) noexcept(
     _CCCL_TRAIT(is_nothrow_move_constructible, _Tp) && _CCCL_TRAIT(is_nothrow_move_assignable, _Tp))
   {
-    const auto __diff = static_cast<ptrdiff_t>(__other.size() - size());
-    if (__diff < 0)
+    if (__other.size() < size())
     {
       const auto __new_end = _CUDA_VSTD::move(__other.begin(), __other.end(), begin());
       __destroy(__new_end, end());
@@ -333,12 +332,6 @@ struct __inplace_vector_base : __inplace_vector_destruct_base<_Tp, _Capacity, _S
   }
 
   // [containers.sequences.inplace.vector.modifiers], modifiers
-  _LIBCUDACXX_INLINE_VISIBILITY void __destroy(iterator __first, iterator __last) noexcept
-  {
-    _CUDA_VSTD::__destroy(__first, __last);
-    __change_size(__first - __last);
-  }
-
   template <class... _Args>
   _LIBCUDACXX_INLINE_VISIBILITY constexpr reference
   unchecked_emplace_back(_Args&&... __args) noexcept(_CCCL_TRAIT(is_nothrow_constructible, _Tp, _Args...))
@@ -348,6 +341,13 @@ struct __inplace_vector_base : __inplace_vector_destruct_base<_Tp, _Capacity, _S
     return *__final;
   }
 
+protected:
+  _LIBCUDACXX_INLINE_VISIBILITY void __destroy(iterator __first, iterator __last) noexcept
+  {
+    _CUDA_VSTD::__destroy(__first, __last);
+    __change_size(__first - __last);
+  }
+
   _LIBCUDACXX_TEMPLATE(bool _IsNothrow = _CCCL_TRAIT(is_nothrow_default_constructible, _Tp))
   _LIBCUDACXX_REQUIRES(_IsNothrow)
   _LIBCUDACXX_INLINE_VISIBILITY void __uninitialized_value_construct(iterator __first, iterator __last) noexcept
@@ -553,6 +553,7 @@ struct __inplace_vector_base<_Tp, _Capacity, __inplace_vector_specialization::__
     return *__final;
   }
 
+protected:
   _LIBCUDACXX_INLINE_VISIBILITY constexpr void __destroy(iterator __first, iterator __last) noexcept
   {
     __change_size(__first - __last);
@@ -664,10 +665,11 @@ struct __inplace_vector_base<_Tp, 0, __inplace_vector_specialization::__empty>
   {
     _LIBCUDACXX_UNREACHABLE();
 #  if defined(_CCCL_COMPILER_MSVC)
-    return *(end() - 1);
+    return *begin();
 #  endif // _CCCL_COMPILER_MSVC
   }
 
+protected:
   _LIBCUDACXX_INLINE_VISIBILITY constexpr void __destroy(iterator, iterator) noexcept
   {
     _LIBCUDACXX_UNREACHABLE();
@@ -720,33 +722,33 @@ public:
   constexpr inplace_vector& operator=(const inplace_vector&) = default;
   constexpr inplace_vector& operator=(inplace_vector&&)      = default;
 
-  _LIBCUDACXX_INLINE_VISIBILITY constexpr explicit inplace_vector(const size_type __size)
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr explicit inplace_vector(const size_type __count)
       : __base()
   {
-    if (__size > 0)
+    if (__count > 0)
     {
-      if (_Capacity < __size)
+      if (_Capacity < __count)
       {
         _CUDA_VSTD::__throw_bad_alloc();
       }
 
       iterator __begin = this->begin();
-      this->__uninitialized_value_construct(__begin, __begin + __size);
+      this->__uninitialized_value_construct(__begin, __begin + __count);
     }
   }
 
-  _LIBCUDACXX_INLINE_VISIBILITY constexpr inplace_vector(const size_type __size, const _Tp& __value)
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr inplace_vector(const size_type __count, const _Tp& __value)
       : __base()
   {
-    if (__size > 0)
+    if (__count > 0)
     {
-      if (_Capacity < __size)
+      if (_Capacity < __count)
       {
         _CUDA_VSTD::__throw_bad_alloc();
       }
 
       iterator __begin = this->begin();
-      this->__uninitialized_fill(__begin, __begin + __size, __value);
+      this->__uninitialized_fill(__begin, __begin + __count, __value);
     }
   }
 
@@ -832,10 +834,10 @@ public:
   _LIBCUDACXX_INLINE_VISIBILITY constexpr inplace_vector(_Range&& __range)
       : __base()
   {
-    const auto __size = static_cast<size_t>(_CUDA_VRANGES::distance(__range.begin(), __range.end()));
-    if (__size > 0)
+    const auto __count = static_cast<size_t>(_CUDA_VRANGES::distance(__range.begin(), __range.end()));
+    if (__count > 0)
     {
-      if (_Capacity < __size)
+      if (_Capacity < __count)
       {
         _CUDA_VSTD::__throw_bad_alloc();
       }
@@ -847,52 +849,52 @@ public:
 
   _LIBCUDACXX_INLINE_VISIBILITY constexpr inplace_vector& operator=(initializer_list<_Tp> __ilist)
   {
+    const auto __count = __ilist.size();
     _CCCL_IF_CONSTEXPR (_Capacity == 0)
     {
-      _LIBCUDACXX_ASSERT(__size == 0, "Cannot assign to inplace_vector with zero capacity ");
+      _LIBCUDACXX_ASSERT(__count == 0, "Cannot assign to inplace_vector with zero capacity ");
       return *this;
     }
 
-    if (_Capacity < __ilist.size())
+    if (_Capacity < __count)
     {
       _CUDA_VSTD::__throw_bad_alloc();
     }
 
-    const auto __diff = static_cast<ptrdiff_t>(__ilist.size() - this->size());
-    if (__diff < 0)
+    const auto __size = this->size();
+    if (__count < __size)
     {
       const iterator __new_end = _CUDA_VSTD::copy(__ilist.begin(), __ilist.end(), this->begin());
       this->__destroy(__new_end, this->end());
     }
     else
     {
-      _CUDA_VSTD::copy(__ilist.begin(), __ilist.begin() + this->size(), this->begin());
-      this->__uninitialized_copy(__ilist.begin() + this->size(), __ilist.end(), this->end());
+      _CUDA_VSTD::copy(__ilist.begin(), __ilist.begin() + __size, this->begin());
+      this->__uninitialized_copy(__ilist.begin() + __size, __ilist.end(), this->end());
     }
     return *this;
   }
 
   // inplace_vector.assign
-  _LIBCUDACXX_INLINE_VISIBILITY constexpr void assign(const size_type __size, const _Tp& __value)
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr void assign(const size_type __count, const _Tp& __value)
   {
     _CCCL_IF_CONSTEXPR (_Capacity == 0)
     {
-      _LIBCUDACXX_ASSERT(__size == 0, "Cannot assign to inplace_vector with zero capacity ");
+      _LIBCUDACXX_ASSERT(__count == 0, "Cannot assign to inplace_vector with zero capacity ");
       return;
     }
 
-    const auto __diff = static_cast<ptrdiff_t>(__size - this->size());
-    if (__diff < 0)
+    const pointer __begin = this->begin();
+    const iterator __end  = this->end();
+    if (__count < this->size())
     {
-      const pointer __begin = this->begin();
-      _CUDA_VSTD::fill(__begin, __begin + __size, __value);
-      this->__destroy(__begin + __size, this->end());
+      _CUDA_VSTD::fill(__begin, __begin + __count, __value);
+      this->__destroy(__begin + __count, __end);
     }
     else
     {
-      const iterator __end = this->end();
-      _CUDA_VSTD::fill(this->begin(), __end, __value);
-      this->__uninitialized_fill(__end, __end + __diff, __value);
+      _CUDA_VSTD::fill(__begin, __end, __value);
+      this->__uninitialized_fill(__end, __begin + __count, __value);
     }
   }
 
@@ -934,7 +936,8 @@ public:
       return;
     }
 
-    const auto __diff = static_cast<ptrdiff_t>(_CUDA_VSTD::distance(__first, __last) - this->size());
+    const auto __diff =
+      static_cast<ptrdiff_t>(_CUDA_VSTD::distance(__first, __last)) - static_cast<ptrdiff_t>(this->size());
     if (__diff < 0)
     {
       const iterator __new_end = _CUDA_VSTD::copy(__first, __last, this->begin());
@@ -956,7 +959,7 @@ public:
       return;
     }
 
-    const auto __diff = static_cast<ptrdiff_t>(__ilist.size() - this->size());
+    const auto __diff = static_cast<ptrdiff_t>(__ilist.size()) - static_cast<ptrdiff_t>(this->size());
     if (__diff < 0)
     {
       const iterator __new_end = _CUDA_VSTD::copy(__ilist.begin(), __ilist.end(), this->begin());
@@ -1014,7 +1017,7 @@ public:
 
     const auto __first = __range.begin();
     const auto __last  = __unwrap_end(__range);
-    const auto __diff  = static_cast<ptrdiff_t>(__size - this->size());
+    const auto __diff  = static_cast<ptrdiff_t>(__size) - static_cast<ptrdiff_t>(this->size());
     if (__diff < 0)
     {
       const iterator __new_end = _CUDA_VSTD::copy(__first, __last, this->begin());
@@ -1042,7 +1045,7 @@ public:
       return;
     }
 
-    const auto __diff = static_cast<ptrdiff_t>(__size - this->size());
+    const auto __diff = static_cast<ptrdiff_t>(__size) - static_cast<ptrdiff_t>(this->size());
     if (__diff < 0)
     {
       const iterator __new_end = _CUDA_VSTD::copy(__first, __last, this->begin());
@@ -1493,6 +1496,11 @@ public:
   _LIBCUDACXX_INLINE_VISIBILITY constexpr _CUDA_VRANGES::iterator_t<_Range>
   try_append_range(_Range&& __range) noexcept(_CCCL_TRAIT(is_nothrow_move_constructible, _Tp))
   {
+    _CCCL_IF_CONSTEXPR (_Capacity == 0)
+    {
+      return __range.begin();
+    }
+
     const auto __capacity = _Capacity - this->size();
     const auto __size     = _CUDA_VRANGES::size(__range);
     const auto __diff     = __size < __capacity ? __size : __capacity;
@@ -1509,6 +1517,11 @@ public:
   _LIBCUDACXX_INLINE_VISIBILITY constexpr _CUDA_VRANGES::iterator_t<_Range>
   try_append_range(_Range&& __range) noexcept(_CCCL_TRAIT(is_nothrow_move_constructible, _Tp))
   {
+    _CCCL_IF_CONSTEXPR (_Capacity == 0)
+    {
+      return __range.begin();
+    }
+
     const auto __capacity  = static_cast<ptrdiff_t>(_Capacity - this->size());
     auto __first           = __range.begin();
     const auto __size      = static_cast<ptrdiff_t>(_CUDA_VRANGES::distance(__first, __unwrap_end(__range)));
@@ -1583,19 +1596,27 @@ public:
 
   _LIBCUDACXX_INLINE_VISIBILITY constexpr void clear() noexcept
   {
+    _CCCL_IF_CONSTEXPR (_Capacity == 0)
+    {
+      return;
+    }
     this->__destroy(this->begin(), this->end());
   }
 
-  _LIBCUDACXX_INLINE_VISIBILITY constexpr void resize(const size_type __size)
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr void resize(const size_type __count)
   {
-    const auto __diff = static_cast<ptrdiff_t>(__size - this->size());
-    if (__diff < 0)
+    const auto __diff = static_cast<ptrdiff_t>(__count) - static_cast<ptrdiff_t>(this->size());
+    if (__diff == 0)
+    {
+      return;
+    }
+    else if (__diff < 0)
     {
-      this->__destroy(this->begin() + __size, this->end());
+      this->__destroy(this->begin() + __count, this->end());
     }
     else
     {
-      if (_Capacity < __size)
+      if (_Capacity < __count)
       {
         _CUDA_VSTD::__throw_bad_alloc();
       }
@@ -1605,16 +1626,20 @@ public:
     }
   }
 
-  _LIBCUDACXX_INLINE_VISIBILITY constexpr void resize(const size_type __size, const _Tp& __value)
+  _LIBCUDACXX_INLINE_VISIBILITY constexpr void resize(const size_type __count, const _Tp& __value)
   {
-    const auto __diff = static_cast<ptrdiff_t>(__size - this->size());
-    if (__diff < 0)
+    const auto __diff = static_cast<ptrdiff_t>(__count) - static_cast<ptrdiff_t>(this->size());
+    if (__diff == 0)
+    {
+      return;
+    }
+    else if (__diff < 0)
     {
-      this->__destroy(this->begin() + __size, this->end());
+      this->__destroy(this->begin() + __count, this->end());
     }
     else
     {
-      if (_Capacity < __size)
+      if (_Capacity < __count)
       {
         _CUDA_VSTD::__throw_bad_alloc();
       }
@@ -1624,9 +1649,9 @@ public:
     }
   }
 
-  _LIBCUDACXX_INLINE_VISIBILITY static constexpr void reserve(const size_type __size)
+  _LIBCUDACXX_INLINE_VISIBILITY static constexpr void reserve(const size_type __count)
   {
-    if (_Capacity < __size)
+    if (_Capacity < __count)
     {
       _CUDA_VSTD::__throw_bad_alloc();
     }
@@ -1720,6 +1745,10 @@ public:
   _LIBCUDACXX_INLINE_VISIBILITY friend constexpr size_type
   erase(inplace_vector& __cont, const _Up& __value) noexcept(_CCCL_TRAIT(is_nothrow_move_assignable, _Tp))
   {
+    _CCCL_IF_CONSTEXPR (_Capacity == 0)
+    {
+      return 0;
+    }
     const pointer __old_end  = __cont.end();
     const iterator __new_end = _CUDA_VSTD::remove(__cont.begin(), __old_end, __value);
     __cont.__destroy(__new_end, __old_end);
@@ -1730,6 +1759,10 @@ public:
   _LIBCUDACXX_INLINE_VISIBILITY friend constexpr size_type
   erase_if(inplace_vector& __cont, _Pred __pred) noexcept(_CCCL_TRAIT(is_nothrow_move_assignable, _Tp))
   {
+    _CCCL_IF_CONSTEXPR (_Capacity == 0)
+    {
+      return 0;
+    }
     const pointer __old_end  = __cont.end();
     const iterator __new_end = _CUDA_VSTD::remove_if(__cont.begin(), __old_end, _CUDA_VSTD::move(__pred));
     __cont.__destroy(__new_end, __old_end);
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/access.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/access.pass.cpp
index 9bdf696de7..6b0296db2b 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/access.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/access.pass.cpp
@@ -74,6 +74,7 @@ __host__ __device__ constexpr void test()
 __host__ __device__ constexpr bool test()
 {
   test<int>();
+  test<Trivial>();
 
   if (!cuda::std::__libcpp_is_constant_evaluated())
   {
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/assign.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/assign.pass.cpp
index ccf9089cab..55e7cb118e 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/assign.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/assign.pass.cpp
@@ -32,32 +32,36 @@ _CCCL_DIAG_SUPPRESS_MSVC(5246)
 template <class T, template <class, size_t> class Range>
 __host__ __device__ constexpr void test_ranges()
 {
-  {
-    cuda::std::inplace_vector<T, 42> input_range_empty{};
-    input_range_empty.assign_range(Range<T, 0>{});
-    assert(input_range_empty.empty());
+  { // inplace_vector<T, 0>::assign_range with an empty input
+    cuda::std::inplace_vector<T, 0> inplace_vector{};
+    inplace_vector.assign_range(Range<T, 0>{});
+    assert(inplace_vector.empty());
   }
 
-  {
-    cuda::std::inplace_vector<T, 42> input_range_shrink_empty{T(1), T(42), T(1337), T(0)};
-    input_range_shrink_empty.assign_range(Range<T, 0>{});
-    assert(input_range_shrink_empty.empty());
+  { // inplace_vector<T, N>::assign_range with an empty input
+    cuda::std::inplace_vector<T, 42> inplace_vector{};
+    inplace_vector.assign_range(Range<T, 0>{});
+    assert(inplace_vector.empty());
   }
 
-  {
-    const cuda::std::array<T, 2> expected = {T(42), T(42)};
-    cuda::std::inplace_vector<T, 42> input_range_shrink{T(1), T(42), T(1337), T(0)};
-    input_range_shrink.assign_range(Range<T, 2>{T(42), T(42)});
-    assert(!input_range_shrink.empty());
-    assert(cuda::std::equal(input_range_shrink.begin(), input_range_shrink.end(), expected.begin(), expected.end()));
+  { // inplace_vector<T, N>::assign_range with an empty input, shrinking
+    cuda::std::inplace_vector<T, 42> inplace_vector{T(1), T(42), T(1337), T(0)};
+    inplace_vector.assign_range(Range<T, 0>{});
+    assert(inplace_vector.empty());
   }
 
-  {
-    const cuda::std::array<T, 6> expected = {T(42), T(42), T(42), T(42), T(42), T(42)};
-    cuda::std::inplace_vector<T, 42> input_range_grow{T(1), T(42), T(1337), T(0)};
-    input_range_grow.assign_range(Range<T, 6>{T(42), T(42), T(42), T(42), T(42), T(42)});
-    assert(!input_range_grow.empty());
-    assert(cuda::std::equal(input_range_grow.begin(), input_range_grow.end(), expected.begin(), expected.end()));
+  { // inplace_vector<T, N>::assign_range with a non-empty input, shrinking
+    cuda::std::inplace_vector<T, 42> inplace_vector{T(1), T(42), T(1337), T(0)};
+    inplace_vector.assign_range(Range<T, 2>{T(42), T(42)});
+    assert(!inplace_vector.empty());
+    assert(equal_range(inplace_vector, cuda::std::array<T, 2>{T(42), T(42)}));
+  }
+
+  { // inplace_vector<T, N>::assign_range with a non-empty input, growing
+    cuda::std::inplace_vector<T, 42> inplace_vector{T(1), T(42), T(1337), T(0)};
+    inplace_vector.assign_range(Range<T, 6>{T(42), T(1), T(42), T(1337), T(0), T(42)});
+    assert(!inplace_vector.empty());
+    assert(equal_range(inplace_vector, cuda::std::array<T, 6>{T(42), T(1), T(42), T(1337), T(0), T(42)}));
   }
 }
 #endif // TEST_STD_VER >= 2017 && !defined(TEST_COMPILER_MSVC_2017)
@@ -110,7 +114,7 @@ __host__ __device__ constexpr void test()
     cuda::std::inplace_vector<T, 42> size_value_shrink{T(1), T(42), T(1337), T(0)};
     size_value_shrink.assign(2, T(42));
     assert(!size_value_shrink.empty());
-    assert(cuda::std::equal(size_value_shrink.begin(), size_value_shrink.end(), expected.begin(), expected.end()));
+    assert(equal_range(size_value_shrink, expected));
   }
 
   {
@@ -118,7 +122,7 @@ __host__ __device__ constexpr void test()
     cuda::std::inplace_vector<T, 42> size_value_grow{T(1), T(42), T(1337), T(0)};
     size_value_grow.assign(6, T(42));
     assert(!size_value_grow.empty());
-    assert(cuda::std::equal(size_value_grow.begin(), size_value_grow.end(), expected.begin(), expected.end()));
+    assert(equal_range(size_value_grow, expected));
   }
 
   {
@@ -143,8 +147,7 @@ __host__ __device__ constexpr void test()
     cuda::std::inplace_vector<T, 42> input_iter_iter_shrink{T(1), T(42), T(1337), T(0)};
     input_iter_iter_shrink.assign(iter{expected.begin()}, iter{expected.end()});
     assert(!input_iter_iter_shrink.empty());
-    assert(
-      cuda::std::equal(input_iter_iter_shrink.begin(), input_iter_iter_shrink.end(), expected.begin(), expected.end()));
+    assert(equal_range(input_iter_iter_shrink, expected));
   }
 
   {
@@ -153,8 +156,7 @@ __host__ __device__ constexpr void test()
     cuda::std::inplace_vector<T, 42> input_iter_iter_grow{T(1), T(42), T(1337), T(0)};
     input_iter_iter_grow.assign(iter{expected.begin()}, iter{expected.end()});
     assert(!input_iter_iter_grow.empty());
-    assert(
-      cuda::std::equal(input_iter_iter_grow.begin(), input_iter_iter_grow.end(), expected.begin(), expected.end()));
+    assert(equal_range(input_iter_iter_grow, expected));
   }
 
   {
@@ -176,7 +178,7 @@ __host__ __device__ constexpr void test()
     cuda::std::inplace_vector<T, 42> iter_iter_shrink{T(1), T(42), T(1337), T(0)};
     iter_iter_shrink.assign(expected.begin(), expected.end());
     assert(!iter_iter_shrink.empty());
-    assert(cuda::std::equal(iter_iter_shrink.begin(), iter_iter_shrink.end(), expected.begin(), expected.end()));
+    assert(equal_range(iter_iter_shrink, expected));
   }
 
   {
@@ -184,7 +186,7 @@ __host__ __device__ constexpr void test()
     cuda::std::inplace_vector<T, 42> iter_iter_grow{T(1), T(42), T(1337), T(0)};
     iter_iter_grow.assign(expected.begin(), expected.end());
     assert(!iter_iter_grow.empty());
-    assert(cuda::std::equal(iter_iter_grow.begin(), iter_iter_grow.end(), expected.begin(), expected.end()));
+    assert(equal_range(iter_iter_grow, expected));
   }
 
   {
@@ -206,7 +208,7 @@ __host__ __device__ constexpr void test()
     cuda::std::inplace_vector<T, 42> init_list_shrink{T(1), T(42), T(1337), T(0)};
     init_list_shrink.assign(expected);
     assert(!init_list_shrink.empty());
-    assert(cuda::std::equal(init_list_shrink.begin(), init_list_shrink.end(), expected.begin(), expected.end()));
+    assert(equal_range(init_list_shrink, expected));
   }
 
   {
@@ -214,7 +216,7 @@ __host__ __device__ constexpr void test()
     cuda::std::inplace_vector<T, 42> init_list_grow{T(1), T(42), T(1337), T(0)};
     init_list_grow.assign(expected);
     assert(!init_list_grow.empty());
-    assert(cuda::std::equal(init_list_grow.begin(), init_list_grow.end(), expected.begin(), expected.end()));
+    assert(equal_range(init_list_grow, expected));
   }
 
 #if TEST_STD_VER >= 2017 && !defined(TEST_COMPILER_MSVC_2017)
@@ -228,6 +230,7 @@ __host__ __device__ constexpr void test()
 __host__ __device__ constexpr bool test()
 {
   test<int>();
+  test<Trivial>();
 
   if (!cuda::std::__libcpp_is_constant_evaluated())
   {
@@ -240,15 +243,15 @@ __host__ __device__ constexpr bool test()
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
+template <template <class, size_t> class Range>
 void test_exceptions()
-{ // assign throws std::bad_alloc
+{ // assign_range throws std::bad_alloc
   constexpr size_t capacity = 4;
-  using vec                 = cuda::std::inplace_vector<int, capacity>;
-
+  using inplace_vector      = cuda::std::inplace_vector<int, capacity>;
+  inplace_vector too_small{};
   try
   {
-    vec too_small{};
-    too_small.assign(2 * capacity, 42);
+    too_small.assign_range(Range<int, 2 + capacity>{0, 1, 2, 3, 4, 5, 6});
   }
   catch (const std::bad_alloc&)
   {}
@@ -256,26 +259,18 @@ void test_exceptions()
   {
     assert(false);
   }
+}
 
-  try
-  {
-    using iter = cpp17_input_iterator<const int*>;
-    cuda::std::array<int, 2 * capacity> input{0, 1, 2, 3, 4, 5, 6, 7};
-    vec too_small{};
-    too_small.assign(iter{input.begin()}, iter{input.end()});
-  }
-  catch (const std::bad_alloc&)
-  {}
-  catch (...)
-  {
-    assert(false);
-  }
+void test_exceptions()
+{ // assign throws std::bad_alloc
+  constexpr size_t capacity = 4;
+  using inplace_vector      = cuda::std::inplace_vector<int, capacity>;
+  inplace_vector too_small{};
+  cuda::std::initializer_list<int> input{0, 1, 2, 3, 4, 5, 6};
 
   try
   {
-    cuda::std::array<int, 2 * capacity> input{0, 1, 2, 3, 4, 5, 6, 7};
-    vec too_small{};
-    too_small.assign(input.begin(), input.end());
+    too_small.assign(2 * capacity);
   }
   catch (const std::bad_alloc&)
   {}
@@ -286,9 +281,7 @@ void test_exceptions()
 
   try
   {
-    cuda::std::initializer_list<int> input{0, 1, 2, 3, 4, 5, 6};
-    vec too_small{};
-    too_small.assign(input);
+    too_small.assign(2 * capacity, 42);
   }
   catch (const std::bad_alloc&)
   {}
@@ -297,12 +290,10 @@ void test_exceptions()
     assert(false);
   }
 
-#  if TEST_STD_VER >= 2017 && !defined(TEST_COMPILER_MSVC_2017)
   try
   {
-    input_range<int, 2 * capacity> input{0, 1, 2, 3, 4, 5, 6, 7};
-    vec too_small{};
-    too_small.assign_range(input);
+    using iter = cpp17_input_iterator<const int*>;
+    too_small.assign(iter{input.begin()}, iter{input.end()});
   }
   catch (const std::bad_alloc&)
   {}
@@ -313,9 +304,7 @@ void test_exceptions()
 
   try
   {
-    uncommon_range<int, 2 * capacity> input{0, 1, 2, 3, 4, 5, 6, 7};
-    vec too_small{};
-    too_small.assign_range(input);
+    too_small.assign(input.begin(), input.end());
   }
   catch (const std::bad_alloc&)
   {}
@@ -326,9 +315,8 @@ void test_exceptions()
 
   try
   {
-    sized_uncommon_range<int, 2 * capacity> input{0, 1, 2, 3, 4, 5, 6, 7};
-    vec too_small{};
-    too_small.assign_range(input);
+    inplace_vector too_small{};
+    too_small.assign(input);
   }
   catch (const std::bad_alloc&)
   {}
@@ -336,6 +324,12 @@ void test_exceptions()
   {
     assert(false);
   }
+
+#  if TEST_STD_VER >= 2017 && !defined(TEST_COMPILER_MSVC_2017)
+  test_exceptions<input_range>();
+  test_exceptions<uncommon_range>();
+  test_exceptions<sized_uncommon_range>();
+  test_exceptions<cuda::std::array>();
 #  endif // TEST_STD_VER >= 2017 && !defined(TEST_COMPILER_MSVC_2017)
 }
 #endif // !TEST_HAS_NO_EXCEPTIONS
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/assignment.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/assignment.pass.cpp
index 7a1123fef7..e54581f6d1 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/assignment.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/assignment.pass.cpp
@@ -26,70 +26,71 @@
 template <class T>
 __host__ __device__ constexpr void test_copy()
 {
+  // Zero capacity inplace_vector is nothrow_copy_assignable
   static_assert(cuda::std::is_nothrow_copy_assignable<cuda::std::inplace_vector<T, 0>>::value, "");
   static_assert(cuda::std::is_nothrow_copy_assignable<cuda::std::inplace_vector<T, 42>>::value
                     == cuda::std::is_nothrow_copy_constructible<T>::value
                   && cuda::std::is_nothrow_copy_assignable<T>::value,
                 "");
 
-  {
+  { // inplace_vector<T, 0> can be copy assigned
     const cuda::std::inplace_vector<T, 0> input{};
     cuda::std::inplace_vector<T, 0> no_capacity{};
     no_capacity = input;
     assert(no_capacity.empty());
   }
 
-  {
-    const cuda::std::inplace_vector<T, 42> input{};
-    cuda::std::inplace_vector<T, 42> empty_to_empty{};
-    empty_to_empty = input;
-    assert(empty_to_empty.empty());
+  using inplace_vector = cuda::std::inplace_vector<T, 42>;
+  { // inplace_vector<T, N> can be copy assigned an empty input
+    const inplace_vector input{};
+    inplace_vector vec{};
+    vec = input;
+    assert(vec.empty());
   }
 
-  {
-    const cuda::std::inplace_vector<T, 42> input{};
-    cuda::std::inplace_vector<T, 42> empty_to_non_empty{T(1), T(42), T(1337), T(0)};
-    empty_to_non_empty = input;
-    assert(empty_to_non_empty.empty());
+  { // inplace_vector<T, N> can be copy assigned an empty input, shrinking
+    const inplace_vector input{};
+    inplace_vector vec{T(1), T(42), T(1337), T(0)};
+    vec = input;
+    assert(vec.empty());
   }
 
-  {
-    const cuda::std::inplace_vector<T, 42> input{T(1), T(42), T(1337), T(0)};
-    cuda::std::inplace_vector<T, 42> non_empty_to_empty{};
-    non_empty_to_empty = input;
-    assert(!non_empty_to_empty.empty());
-    assert(cuda::std::equal(non_empty_to_empty.begin(), non_empty_to_empty.end(), input.begin(), input.end()));
+  { // inplace_vector<T, N> can be copy assigned a non-empty input, growing from empty
+    const inplace_vector input{T(1), T(42), T(1337), T(0)};
+    inplace_vector vec{};
+    vec = input;
+    assert(!vec.empty());
+    assert(equal_range(vec, input));
   }
 
-  {
-    const cuda::std::inplace_vector<T, 42> input{T(1), T(42), T(1337), T(0)};
-    cuda::std::inplace_vector<T, 42> non_empty_to_non_empty_shrink{T(0), T(42), T(1337), T(42), T(5)};
-    non_empty_to_non_empty_shrink = input;
-    assert(!non_empty_to_non_empty_shrink.empty());
-    assert(cuda::std::equal(
-      non_empty_to_non_empty_shrink.begin(), non_empty_to_non_empty_shrink.end(), input.begin(), input.end()));
+  { // inplace_vector<T, N> can be copy assigned a non-empty input, shrinking
+    const inplace_vector input{T(1), T(42), T(1337), T(0)};
+    inplace_vector vec{T(0), T(42), T(1337), T(42), T(5)};
+    vec = input;
+    assert(!vec.empty());
+    assert(equal_range(vec, input));
   }
 
-  {
-    const cuda::std::inplace_vector<T, 42> input{T(1), T(42), T(1337), T(0)};
-    cuda::std::inplace_vector<T, 42> non_empty_to_non_empty_grow{T(0), T(42)};
-    non_empty_to_non_empty_grow = input;
-    assert(!non_empty_to_non_empty_grow.empty());
-    assert(cuda::std::equal(
-      non_empty_to_non_empty_grow.begin(), non_empty_to_non_empty_grow.end(), input.begin(), input.end()));
+  { // inplace_vector<T, N> can be copy assigned a non-empty input, growing
+    const inplace_vector input{T(1), T(42), T(1337), T(0)};
+    inplace_vector vec{T(0), T(42)};
+    vec = input;
+    assert(!vec.empty());
+    assert(equal_range(vec, input));
   }
 }
 
 template <class T>
 __host__ __device__ constexpr void test_move()
 {
+  // Zero capacity inplace_vector is nothrow_move_assignable
   static_assert(cuda::std::is_nothrow_move_assignable<cuda::std::inplace_vector<T, 0>>::value, "");
   static_assert(cuda::std::is_nothrow_move_assignable<cuda::std::inplace_vector<T, 42>>::value
                     == cuda::std::is_nothrow_move_constructible<T>::value
                   && cuda::std::is_nothrow_move_assignable<T>::value,
                 "");
 
-  {
+  { // inplace_vector<T, 0> can be move assigned
     cuda::std::inplace_vector<T, 0> input{};
     cuda::std::inplace_vector<T, 0> no_capacity{};
     no_capacity = cuda::std::move(input);
@@ -97,101 +98,96 @@ __host__ __device__ constexpr void test_move()
     assert(input.empty());
   }
 
-  {
-    cuda::std::inplace_vector<T, 42> input{};
-    cuda::std::inplace_vector<T, 42> empty_to_empty{};
-    empty_to_empty = cuda::std::move(input);
-    assert(empty_to_empty.empty());
+  using inplace_vector = cuda::std::inplace_vector<T, 42>;
+  { // inplace_vector<T, N> can be move assigned an empty input
+    inplace_vector input{};
+    inplace_vector vec{};
+    vec = cuda::std::move(input);
+    assert(vec.empty());
     assert(input.empty());
   }
 
-  {
-    cuda::std::inplace_vector<T, 42> input{};
-    cuda::std::inplace_vector<T, 42> empty_to_non_empty{T(1), T(42), T(1337), T(0)};
-    empty_to_non_empty = cuda::std::move(input);
-    assert(empty_to_non_empty.empty());
+  { // inplace_vector<T, N> can be move assigned an empty input, shrinking
+    inplace_vector input{};
+    inplace_vector vec{T(1), T(42), T(1337), T(0)};
+    vec = cuda::std::move(input);
+    assert(vec.empty());
     assert(input.empty());
   }
 
-  const cuda::std::initializer_list<T> expected{T(1), T(42), T(1337), T(0)};
-  {
-    cuda::std::inplace_vector<T, 42> input{T(1), T(42), T(1337), T(0)};
-    cuda::std::inplace_vector<T, 42> non_empty_to_empty{};
-    non_empty_to_empty = cuda::std::move(input);
-    assert(!non_empty_to_empty.empty());
-    assert(cuda::std::equal(non_empty_to_empty.begin(), non_empty_to_empty.end(), expected.begin(), expected.end()));
+  const cuda::std::array<T, 4> expected{T(1), T(42), T(1337), T(0)};
+  { // inplace_vector<T, N> can be move assigned a non-empty input, growing from empty. clears input
+    inplace_vector input{T(1), T(42), T(1337), T(0)};
+    inplace_vector vec{};
+    vec = cuda::std::move(input);
+    assert(!vec.empty());
     assert(input.empty());
+    assert(equal_range(vec, expected));
   }
 
-  {
-    cuda::std::inplace_vector<T, 42> input{T(1), T(42), T(1337), T(0)};
-    cuda::std::inplace_vector<T, 42> non_empty_to_non_empty_shrink{T(0), T(42), T(1337), T(42), T(5)};
-    non_empty_to_non_empty_shrink = cuda::std::move(input);
-    assert(!non_empty_to_non_empty_shrink.empty());
-    assert(cuda::std::equal(
-      non_empty_to_non_empty_shrink.begin(), non_empty_to_non_empty_shrink.end(), expected.begin(), expected.end()));
+  { // inplace_vector<T, N> can be move assigned a non-empty input, shrinking. clears input
+    inplace_vector input{T(1), T(42), T(1337), T(0)};
+    inplace_vector vec{T(0), T(42), T(1337), T(42), T(5)};
+    vec = cuda::std::move(input);
+    assert(!vec.empty());
     assert(input.empty());
+    assert(equal_range(vec, expected));
   }
 
-  {
-    cuda::std::inplace_vector<T, 42> input{T(1), T(42), T(1337), T(0)};
-    cuda::std::inplace_vector<T, 42> non_empty_to_non_empty_grow{T(0), T(42)};
-    non_empty_to_non_empty_grow = cuda::std::move(input);
-    assert(!non_empty_to_non_empty_grow.empty());
-    assert(cuda::std::equal(
-      non_empty_to_non_empty_grow.begin(), non_empty_to_non_empty_grow.end(), expected.begin(), expected.end()));
+  { // inplace_vector<T, N> can be move assigned a non-empty input, growing. clears input
+    inplace_vector input{T(1), T(42), T(1337), T(0)};
+    inplace_vector vec{T(0), T(42)};
+    vec = cuda::std::move(input);
+    assert(!vec.empty());
     assert(input.empty());
+    assert(equal_range(vec, expected));
   }
 }
 
 template <class T>
 __host__ __device__ constexpr void test_init_list()
 {
-  {
+  { // inplace_vector<T, 0> can be assigned an empty initializer_list
     const cuda::std::initializer_list<T> input{};
-    cuda::std::inplace_vector<T, 0> no_capacity{};
-    no_capacity = input;
-    assert(no_capacity.empty());
+    cuda::std::inplace_vector<T, 0> vec{};
+    vec = input;
+    assert(vec.empty());
   }
 
-  {
-    const cuda::std::initializer_list<T> input{};
-    cuda::std::inplace_vector<T, 42> empty_to_empty{};
-    empty_to_empty = input;
-    assert(empty_to_empty.empty());
+  using inplace_vector = cuda::std::inplace_vector<T, 42>;
+  const cuda::std::initializer_list<T> empty_input{};
+  { // inplace_vector<T, N> can be assigned an empty initializer_list
+    cuda::std::inplace_vector<T, 42> vec{};
+    vec = empty_input;
+    assert(vec.empty());
   }
 
-  {
-    const cuda::std::initializer_list<T> input{};
-    cuda::std::inplace_vector<T, 42> empty_to_non_empty{T(1), T(42), T(1337), T(0)};
-    empty_to_non_empty = input;
-    assert(empty_to_non_empty.empty());
+  { // inplace_vector<T, N> can be assigned an empty initializer_list, shrinking
+    cuda::std::inplace_vector<T, 42> vec{T(1), T(42), T(1337), T(0)};
+    vec = empty_input;
+    assert(vec.empty());
   }
 
-  {
-    const cuda::std::initializer_list<T> input{T(1), T(42), T(1337), T(0)};
-    cuda::std::inplace_vector<T, 42> non_empty_to_empty{};
-    non_empty_to_empty = input;
-    assert(!non_empty_to_empty.empty());
-    assert(cuda::std::equal(non_empty_to_empty.begin(), non_empty_to_empty.end(), input.begin(), input.end()));
+  const cuda::std::initializer_list<T> input{T(1), T(42), T(1337), T(0)};
+  { // inplace_vector<T, N> can be assigned a non-empty initializer_list, from empty
+    cuda::std::inplace_vector<T, 42> vec{};
+    vec = input;
+    assert(!vec.empty());
+    assert(equal_range(vec, input));
   }
 
-  {
-    const cuda::std::initializer_list<T> input{T(1), T(42), T(1337), T(0)};
-    cuda::std::inplace_vector<T, 42> non_empty_to_non_empty_shrink{T(0), T(42), T(1337), T(42), T(5)};
-    non_empty_to_non_empty_shrink = input;
-    assert(!non_empty_to_non_empty_shrink.empty());
-    assert(cuda::std::equal(
-      non_empty_to_non_empty_shrink.begin(), non_empty_to_non_empty_shrink.end(), input.begin(), input.end()));
+  { // inplace_vector<T, N> can be assigned a non-empty initializer_list, shrinking
+    cuda::std::inplace_vector<T, 42> vec{T(0), T(42), T(1337), T(42), T(5)};
+    vec = input;
+    assert(!vec.empty());
+    assert(equal_range(vec, input));
   }
 
-  {
-    const cuda::std::initializer_list<T> input{T(1), T(42), T(1337), T(0)};
-    cuda::std::inplace_vector<T, 42> non_empty_to_non_empty_grow{T(0), T(42)};
-    non_empty_to_non_empty_grow = input;
-    assert(!non_empty_to_non_empty_grow.empty());
-    assert(cuda::std::equal(
-      non_empty_to_non_empty_grow.begin(), non_empty_to_non_empty_grow.end(), input.begin(), input.end()));
+  { // inplace_vector<T, N> can be assigned a non-empty initializer_list, growing from non empty
+    cuda::std::inplace_vector<T, 42> vec{T(0), T(42)};
+    vec = input;
+    assert(!vec.empty());
+    assert(equal_range(vec, input));
   }
 }
 
@@ -206,6 +202,7 @@ __host__ __device__ constexpr void test()
 __host__ __device__ constexpr bool test()
 {
   test<int>();
+  test<Trivial>();
 
   if (!cuda::std::__libcpp_is_constant_evaluated())
   {
@@ -221,12 +218,12 @@ __host__ __device__ constexpr bool test()
 void test_exceptions()
 { // assignment throws std::bad_alloc
   constexpr size_t capacity = 4;
-  using vec                 = cuda::std::inplace_vector<int, capacity>;
+  using inplace_vector      = cuda::std::inplace_vector<int, capacity>;
+  inplace_vector too_small{};
 
   try
   {
     cuda::std::initializer_list<int> input{0, 1, 2, 3, 4, 5, 6};
-    vec too_small{};
     too_small = input;
   }
   catch (const std::bad_alloc&)
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/capacity.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/capacity.pass.cpp
index 39f88e446d..fc1354c6f5 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/capacity.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/capacity.pass.cpp
@@ -24,9 +24,9 @@ template <class T>
 __host__ __device__ constexpr void test()
 {
   constexpr size_t max_capacity = 42ull;
-  using vec                     = cuda::std::inplace_vector<T, max_capacity>;
-  vec range{T(1), T(1337), T(42), T(12), T(0), T(-1)};
-  const vec const_range{T(0), T(42), T(1337), T(42), T(5), T(-42)};
+  using inplace_vector          = cuda::std::inplace_vector<T, max_capacity>;
+  inplace_vector range{T(1), T(1337), T(42), T(12), T(0), T(-1)};
+  const inplace_vector const_range{T(0), T(42), T(1337), T(42), T(5), T(-42)};
 
   const auto empty = range.empty();
   static_assert(cuda::std::is_same<decltype(empty), const bool>::value, "");
@@ -37,33 +37,34 @@ __host__ __device__ constexpr void test()
   assert(!const_empty);
 
   const auto size = range.size();
-  static_assert(cuda::std::is_same<decltype(size), const typename vec::size_type>::value, "");
+  static_assert(cuda::std::is_same<decltype(size), const typename inplace_vector::size_type>::value, "");
   assert(size == 6);
 
   const auto const_size = const_range.size();
-  static_assert(cuda::std::is_same<decltype(const_size), const typename vec::size_type>::value, "");
+  static_assert(cuda::std::is_same<decltype(const_size), const typename inplace_vector::size_type>::value, "");
   assert(const_size == 6);
 
   const auto max_size = range.max_size();
-  static_assert(cuda::std::is_same<decltype(max_size), const typename vec::size_type>::value, "");
+  static_assert(cuda::std::is_same<decltype(max_size), const typename inplace_vector::size_type>::value, "");
   assert(max_size == max_capacity);
 
   const auto const_max_size = const_range.max_size();
-  static_assert(cuda::std::is_same<decltype(const_max_size), const typename vec::size_type>::value, "");
+  static_assert(cuda::std::is_same<decltype(const_max_size), const typename inplace_vector::size_type>::value, "");
   assert(const_max_size == max_capacity);
 
   const auto capacity = range.capacity();
-  static_assert(cuda::std::is_same<decltype(capacity), const typename vec::size_type>::value, "");
+  static_assert(cuda::std::is_same<decltype(capacity), const typename inplace_vector::size_type>::value, "");
   assert(capacity == max_capacity);
 
   const auto const_capacity = const_range.capacity();
-  static_assert(cuda::std::is_same<decltype(const_capacity), const typename vec::size_type>::value, "");
+  static_assert(cuda::std::is_same<decltype(const_capacity), const typename inplace_vector::size_type>::value, "");
   assert(const_capacity == max_capacity);
 }
 
 __host__ __device__ constexpr bool test()
 {
   test<int>();
+  test<Trivial>();
 
   if (!cuda::std::__libcpp_is_constant_evaluated())
   {
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/comparison.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/comparison.pass.cpp
index 6b9d5ac088..7924fd189b 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/comparison.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/comparison.pass.cpp
@@ -23,10 +23,10 @@ template <class T>
 __host__ __device__ constexpr void test_equality()
 {
   constexpr size_t max_capacity = 42ull;
-  using vec                     = cuda::std::inplace_vector<T, max_capacity>;
+  using inplace_vector          = cuda::std::inplace_vector<T, max_capacity>;
 
-  vec lhs{T(1), T(42), T(1337), T(0)};
-  vec rhs{T(0), T(1), T(2), T(3), T(4)};
+  inplace_vector lhs{T(1), T(42), T(1337), T(0)};
+  inplace_vector rhs{T(0), T(1), T(2), T(3), T(4)};
 
   auto res_equality = lhs == lhs;
   static_assert(cuda::std::is_same<decltype(res_equality), bool>::value, "");
@@ -41,10 +41,10 @@ template <class T>
 __host__ __device__ constexpr void test_relation()
 {
   constexpr size_t max_capacity = 42ull;
-  using vec                     = cuda::std::inplace_vector<T, max_capacity>;
+  using inplace_vector          = cuda::std::inplace_vector<T, max_capacity>;
 
-  vec lhs{T(0), T(1), T(1), T(3), T(4)};
-  vec rhs{T(0), T(1), T(2), T(3), T(4)};
+  inplace_vector lhs{T(0), T(1), T(1), T(3), T(4)};
+  inplace_vector rhs{T(0), T(1), T(2), T(3), T(4)};
 
   auto res_less = lhs < rhs;
   static_assert(cuda::std::is_same<decltype(res_less), bool>::value, "");
@@ -73,6 +73,7 @@ __host__ __device__ constexpr void test()
 __host__ __device__ constexpr bool test()
 {
   test<int>();
+  test<Trivial>();
 
   if (!cuda::std::__libcpp_is_constant_evaluated())
   {
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/constructor.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/constructor.pass.cpp
index e06d96f6dc..8909ce48a8 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/constructor.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/constructor.pass.cpp
@@ -32,15 +32,15 @@ _CCCL_DIAG_SUPPRESS_MSVC(5246)
 template <class T>
 __host__ __device__ constexpr void test_default()
 {
-  {
-    cuda::std::inplace_vector<T, 0> no_capacity{};
-    assert(no_capacity.empty());
+  { // inplace_vecto<T, 0> is default_constructible
+    cuda::std::inplace_vector<T, 0> vec{};
+    assert(vec.empty());
     static_assert(cuda::std::is_nothrow_default_constructible<cuda::std::inplace_vector<T, 0>>::value, "");
   }
 
-  {
-    cuda::std::inplace_vector<T, 42> with_capacity{};
-    assert(with_capacity.empty());
+  { // inplace_vecto<T, N> is default_constructible
+    cuda::std::inplace_vector<T, 42> vec{};
+    assert(vec.empty());
     static_assert(cuda::std::is_nothrow_default_constructible<cuda::std::inplace_vector<T, 42>>::value, "");
   }
 }
@@ -48,167 +48,173 @@ __host__ __device__ constexpr void test_default()
 template <class T>
 __host__ __device__ constexpr void test_copy_move()
 {
+  // Zero capacity inplace_vector is trivial
   static_assert(cuda::std::is_nothrow_copy_constructible<cuda::std::inplace_vector<T, 0>>::value, "");
   static_assert(cuda::std::is_nothrow_move_constructible<cuda::std::inplace_vector<T, 0>>::value, "");
-
   static_assert(cuda::std::is_nothrow_copy_constructible<cuda::std::inplace_vector<T, 42>>::value
                   == cuda::std::is_nothrow_copy_constructible<T>::value,
                 "");
   static_assert(cuda::std::is_nothrow_move_constructible<cuda::std::inplace_vector<T, 42>>::value
                   == cuda::std::is_nothrow_move_constructible<T>::value,
                 "");
-  {
+  { // inplace_vector<T, 0> can be copy constructed
     cuda::std::inplace_vector<T, 0> input{};
-    cuda::std::inplace_vector<T, 0> no_capacity_copy(input);
-    assert(no_capacity_copy.empty());
+    cuda::std::inplace_vector<T, 0> vec(input);
+    assert(vec.empty());
+  }
 
-    cuda::std::inplace_vector<T, 0> no_capacity_move(cuda::std::move(input));
-    assert(no_capacity_move.empty());
+  { // inplace_vector<T, 0> can be move constructed
+    cuda::std::inplace_vector<T, 0> input{};
+    cuda::std::inplace_vector<T, 0> vec(cuda::std::move(input));
+    assert(input.empty());
+    assert(vec.empty());
   }
 
-  {
-    cuda::std::inplace_vector<T, 42> input{};
-    cuda::std::inplace_vector<T, 42> with_capacity_empty_copy(input);
-    assert(with_capacity_empty_copy.empty());
+  using inplace_vector = cuda::std::inplace_vector<T, 42>;
+  { // inplace_vector<T, N> can be copy constructed from empty input
+    const inplace_vector input{};
+    inplace_vector vec(input);
+    assert(vec.empty());
+  }
 
-    cuda::std::inplace_vector<T, 42> with_capacity_empty_move(cuda::std::move(input));
-    assert(with_capacity_empty_move.empty());
+  { // inplace_vector<T, N> can be move constructed with empty input
+    inplace_vector input{};
+    inplace_vector vec(cuda::std::move(input));
+    assert(vec.empty());
+    assert(input.empty());
   }
 
-  {
-    cuda::std::inplace_vector<T, 42> input{T(1), T(42), T(1337), T(0)};
-    cuda::std::inplace_vector<T, 42> with_capacity_copy(input);
-    assert(!with_capacity_copy.empty());
-    assert(with_capacity_copy.size() == input.size());
-    assert(cuda::std::equal(with_capacity_copy.begin(), with_capacity_copy.end(), input.begin(), input.end()));
+  { // inplace_vector<T, N> can be copy constructed from non-empty input
+    inplace_vector input{T(1), T(42), T(1337), T(0)};
+    inplace_vector vec(input);
+    assert(!vec.empty());
+    assert(equal_range(vec, input));
+  }
 
-    cuda::std::inplace_vector<T, 42> with_capacity_move(cuda::std::move(input));
+  { // inplace_vector<T, N> can be move constructed from non-empty input, clears input
+    inplace_vector input{T(1), T(42), T(1337), T(0)};
+    inplace_vector vec(cuda::std::move(input));
+    assert(!vec.empty());
     assert(input.empty());
-    assert(!with_capacity_move.empty());
-    assert(with_capacity_copy.size() == with_capacity_copy.size());
-    assert(cuda::std::equal(
-      with_capacity_copy.begin(), with_capacity_copy.end(), with_capacity_copy.begin(), with_capacity_copy.end()));
+    assert(equal_range(vec, cuda::std::array<T, 4>{T(1), T(42), T(1337), T(0)}));
   }
 }
 
 template <class T>
 __host__ __device__ constexpr void test_size()
 {
-  {
-    cuda::std::inplace_vector<T, 0> no_capacity(0);
-    assert(no_capacity.empty());
+  { // inplace_vector<T, 0> can be constructed from a size
+    cuda::std::inplace_vector<T, 0> vec(0);
+    assert(vec.empty());
     static_assert(!noexcept(cuda::std::inplace_vector<T, 0>(0)), "");
   }
 
-  {
-    cuda::std::inplace_vector<T, 42> with_capacity_empty(0);
-    assert(with_capacity_empty.empty());
-    static_assert(!noexcept(cuda::std::inplace_vector<T, 42>(0)), "");
+  using inplace_vector = cuda::std::inplace_vector<T, 42>;
+  { // inplace_vector<T, N> can be constructed from a size, is empty if zero
+    inplace_vector vec(0);
+    assert(vec.empty());
+    static_assert(!noexcept(inplace_vector(0)), "");
   }
 
-  {
-    cuda::std::inplace_vector<T, 42> with_capacity_non_empty(3);
-    assert(!with_capacity_non_empty.empty());
-    assert(with_capacity_non_empty.size() == 3);
-    static_assert(!noexcept(cuda::std::inplace_vector<T, 42>(3)), "");
-
-    const T expected[] = {T(), T(), T()};
-    assert(cuda::std::equal(with_capacity_non_empty.begin(), with_capacity_non_empty.end(), expected, expected + 3));
+  { // inplace_vector<T, N> can be constructed from a size, elements are value initialized
+    constexpr size_t size{3};
+    inplace_vector vec(size);
+    assert(!vec.empty());
+    assert(equal_range(vec, cuda::std::array<T, size>{T(0), T(0), T(0)}));
+    static_assert(!noexcept(inplace_vector(3)), "");
   }
 }
 
 template <class T>
 __host__ __device__ constexpr void test_size_value()
 {
-  {
-    cuda::std::inplace_vector<T, 0> no_capacity(0, T(42));
-    assert(no_capacity.empty());
+  { // inplace_vector<T, 0> can be constructed from a size and a const T&
+    cuda::std::inplace_vector<T, 0> vec(0, T(42));
+    assert(vec.empty());
     static_assert(!noexcept(cuda::std::inplace_vector<T, 0>(0, T(42))), "");
   }
 
-  {
-    cuda::std::inplace_vector<T, 42> with_capacity_empty(0, T(42));
-    assert(with_capacity_empty.empty());
-    static_assert(!noexcept(cuda::std::inplace_vector<T, 42>(0, T(42))), "");
+  using inplace_vector = cuda::std::inplace_vector<T, 42>;
+  { // inplace_vector<T, N> can be constructed from a size and a const T&, is empty if zero
+    inplace_vector vec(0, T(42));
+    assert(vec.empty());
+    static_assert(!noexcept(inplace_vector(0, T(42))), "");
   }
 
-  {
-    cuda::std::inplace_vector<T, 42> with_capacity_non_empty(3, T(42));
-    assert(!with_capacity_non_empty.empty());
-    assert(with_capacity_non_empty.size() == 3);
-    static_assert(!noexcept(cuda::std::inplace_vector<T, 42>(3, T(42))), "");
-
-    const T expected[] = {T(42), T(42), T(42)};
-    assert(cuda::std::equal(with_capacity_non_empty.begin(), with_capacity_non_empty.end(), expected, expected + 3));
+  { // inplace_vector<T, N> can be constructed from a size and a const T&, elements are copied
+    constexpr size_t size{3};
+    inplace_vector vec(size, T(42));
+    assert(!vec.empty());
+    assert(equal_range(vec, cuda::std::array<T, size>{T(42), T(42), T(42)}));
+    static_assert(!noexcept(inplace_vector(3, T(42))), "");
   }
 }
 
 template <class T>
 __host__ __device__ constexpr void test_iter()
 {
-  const T input[] = {T(1), T(42), T(1337), T(0)};
-  {
+  const cuda::std::array<T, 4> input{T(1), T(42), T(1337), T(0)};
+  { // inplace_vector<T, 0> can be constructed from two equal input iterators
     using iter = cpp17_input_iterator<const T*>;
-    cuda::std::inplace_vector<T, 0> from_input_iter_no_capacity(iter{input}, iter{input});
-    assert(from_input_iter_no_capacity.empty());
+    cuda::std::inplace_vector<T, 0> vec(iter{input.begin()}, iter{input.begin()});
+    assert(vec.empty());
   }
 
-  {
+  { // inplace_vector<T, 0> can be constructed from two equal forward iterators
     using iter = forward_iterator<const T*>;
-    cuda::std::inplace_vector<T, 0> from_forward_iter_no_capacity(iter{input}, iter{input});
-    assert(from_forward_iter_no_capacity.empty());
+    cuda::std::inplace_vector<T, 0> vec(iter{input.begin()}, iter{input.begin()});
+    assert(vec.empty());
   }
 
-  {
+  using inplace_vector = cuda::std::inplace_vector<T, 42>;
+  { // inplace_vector<T, N> can be constructed from two equal input iterators
     using iter = cpp17_input_iterator<const T*>;
-    cuda::std::inplace_vector<T, 42> from_input_iter_empty(iter{input}, iter{input});
-    assert(from_input_iter_empty.empty());
+    inplace_vector vec(iter{input.begin()}, iter{input.begin()});
+    assert(vec.empty());
   }
 
-  {
+  { // inplace_vector<T, N> can be constructed from two equal forward iterators
     using iter = forward_iterator<const T*>;
-    cuda::std::inplace_vector<T, 42> from_forward_iter_empty(iter{input}, iter{input});
-    assert(from_forward_iter_empty.empty());
+    inplace_vector vec(iter{input.begin()}, iter{input.begin()});
+    assert(vec.empty());
   }
 
-  {
+  { // inplace_vector<T, N> can be constructed from two input iterators
     using iter = cpp17_input_iterator<const T*>;
-    cuda::std::inplace_vector<T, 42> from_input_iter_non_empty(iter{input}, iter{input + 3});
-    assert(!from_input_iter_non_empty.empty());
-    assert(from_input_iter_non_empty.size() == 3);
-    assert(cuda::std::equal(from_input_iter_non_empty.begin(), from_input_iter_non_empty.end(), input, input + 3));
+    inplace_vector vec(iter{input.begin()}, iter{input.end()});
+    assert(!vec.empty());
+    assert(equal_range(vec, input));
   }
 
-  {
+  { // inplace_vector<T, N> can be constructed from two forward iterators
     using iter = forward_iterator<const T*>;
-    cuda::std::inplace_vector<T, 42> from_forward_iter_non_empty(iter{input}, iter{input + 3});
-    assert(!from_forward_iter_non_empty.empty());
-    assert(from_forward_iter_non_empty.size() == 3);
-    assert(cuda::std::equal(from_forward_iter_non_empty.begin(), from_forward_iter_non_empty.end(), input, input + 3));
+    inplace_vector vec(iter{input.begin()}, iter{input.end()});
+    assert(!vec.empty());
+    assert(equal_range(vec, input));
   }
 }
 
 template <class T>
 __host__ __device__ constexpr void test_init_list()
 {
-  {
+  { // inplace_vector<T, 0> can be constructed from an empty initializer_list
     cuda::std::initializer_list<T> input{};
-    cuda::std::inplace_vector<T, 0> no_capacity(input);
-    assert(no_capacity.empty());
+    cuda::std::inplace_vector<T, 0> vec(input);
+    assert(vec.empty());
   }
 
-  {
+  using inplace_vector = cuda::std::inplace_vector<T, 42>;
+  { // inplace_vector<T, N> can be constructed from an empty initializer_list
     cuda::std::initializer_list<T> input{};
-    cuda::std::inplace_vector<T, 42> from_empty(input);
-    assert(from_empty.empty());
+    inplace_vector vec(input);
+    assert(vec.empty());
   }
 
-  {
-    cuda::std::initializer_list<T> input{T(1), T(42), T(1337), T(0)};
-    cuda::std::inplace_vector<T, 42> from_non_empty(input);
-    assert(!from_non_empty.empty());
-    assert(from_non_empty.size() == input.size());
-    assert(cuda::std::equal(from_non_empty.begin(), from_non_empty.end(), input.begin(), input.end()));
+  { // inplace_vector<T, N> can be constructed from a non- empty initializer_list
+    const cuda::std::initializer_list<T> input{T(1), T(42), T(1337), T(0)};
+    inplace_vector vec(input);
+    assert(!vec.empty());
+    assert(equal_range(vec, input));
   }
 }
 
@@ -216,22 +222,21 @@ __host__ __device__ constexpr void test_init_list()
 template <class T, template <class, size_t> class Range>
 __host__ __device__ constexpr void test_range()
 {
-  {
-    cuda::std::inplace_vector<T, 0> no_capacity(Range<T, 0>{});
-    assert(no_capacity.empty());
+  { // inplace_vector<T, 0> can be constructed from an empty range
+    cuda::std::inplace_vector<T, 0> vec(Range<T, 0>{});
+    assert(vec.empty());
   }
 
-  {
-    cuda::std::inplace_vector<T, 42> from_empty(Range<T, 0>{});
-    assert(from_empty.empty());
+  using inplace_vector = cuda::std::inplace_vector<T, 42>;
+  { // inplace_vector<T, N> can be constructed from an empty range
+    inplace_vector vec(Range<T, 0>{});
+    assert(vec.empty());
   }
 
-  {
-    const cuda::std::array<T, 4> expected{T(1), T(42), T(1337), T(0)};
-    cuda::std::inplace_vector<T, 42> from_non_empty(Range<T, 4>{T(1), T(42), T(1337), T(0)});
-    assert(!from_non_empty.empty());
-    assert(from_non_empty.size() == expected.size());
-    assert(cuda::std::equal(from_non_empty.begin(), from_non_empty.end(), expected.begin(), expected.end()));
+  { // inplace_vector<T, N> can be constructed from a non-empty range
+    inplace_vector vec(Range<T, 4>{T(1), T(42), T(1337), T(0)});
+    assert(!vec.empty());
+    assert(equal_range(vec, cuda::std::array<T, 4>{T(1), T(42), T(1337), T(0)}));
   }
 }
 
@@ -280,6 +285,7 @@ __host__ __device__ constexpr void test()
 __host__ __device__ constexpr bool test()
 {
   test<int>();
+  test<Trivial>();
   test<NonTrivial>();
   test<ThrowingDefaultConstruct>();
   test<ThrowingCopyConstructor>();
@@ -298,11 +304,11 @@ __host__ __device__ constexpr bool test()
 void test_exceptions()
 { // constructors throw std::bad_alloc
   constexpr size_t capacity = 4;
-  using vec                 = cuda::std::inplace_vector<int, capacity>;
+  using inplace_vector      = cuda::std::inplace_vector<int, capacity>;
 
   try
   {
-    vec too_small(2 * capacity);
+    inplace_vector too_small(2 * capacity);
   }
   catch (const std::bad_alloc&)
   {}
@@ -313,7 +319,7 @@ void test_exceptions()
 
   try
   {
-    vec too_small(2 * capacity, 42);
+    inplace_vector too_small(2 * capacity, 42);
   }
   catch (const std::bad_alloc&)
   {}
@@ -326,7 +332,7 @@ void test_exceptions()
   {
     using iter = cpp17_input_iterator<const int*>;
     cuda::std::array<int, 2 * capacity> input{0, 1, 2, 3, 4, 5, 6, 7};
-    vec too_small(iter{input.begin()}, iter{input.end()});
+    inplace_vector too_small(iter{input.begin()}, iter{input.end()});
   }
   catch (const std::bad_alloc&)
   {}
@@ -338,7 +344,7 @@ void test_exceptions()
   try
   {
     cuda::std::array<int, 2 * capacity> input{0, 1, 2, 3, 4, 5, 6, 7};
-    vec too_small(input.begin(), input.end());
+    inplace_vector too_small(input.begin(), input.end());
   }
   catch (const std::bad_alloc&)
   {}
@@ -350,7 +356,7 @@ void test_exceptions()
   try
   {
     cuda::std::initializer_list<int> input{0, 1, 2, 3, 4, 5, 6};
-    vec too_small(input);
+    inplace_vector too_small(input);
   }
   catch (const std::bad_alloc&)
   {}
@@ -363,7 +369,7 @@ void test_exceptions()
   try
   {
     input_range<int, 2 * capacity> input{{0, 1, 2, 3, 4, 5, 6, 7}};
-    vec too_small(input);
+    inplace_vector too_small(input);
   }
   catch (const std::bad_alloc&)
   {}
@@ -375,7 +381,7 @@ void test_exceptions()
   try
   {
     uncommon_range<int, 2 * capacity> input{{0, 1, 2, 3, 4, 5, 6, 7}};
-    vec too_small(input);
+    inplace_vector too_small(input);
   }
   catch (const std::bad_alloc&)
   {}
@@ -387,7 +393,7 @@ void test_exceptions()
   try
   {
     sized_uncommon_range<int, 2 * capacity> input{{0, 1, 2, 3, 4, 5, 6, 7}};
-    vec too_small(input);
+    inplace_vector too_small(input);
   }
   catch (const std::bad_alloc&)
   {}
@@ -399,7 +405,7 @@ void test_exceptions()
   try
   {
     cuda::std::array<int, 2 * capacity> input{0, 1, 2, 3, 4, 5, 6, 7};
-    vec too_small(input);
+    inplace_vector too_small(input);
   }
   catch (const std::bad_alloc&)
   {}
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/emplace.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/emplace.pass.cpp
index bd0021740b..1636023b74 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/emplace.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/emplace.pass.cpp
@@ -27,152 +27,174 @@
 template <class T>
 __host__ __device__ constexpr void test()
 {
-  constexpr size_t max_capacity         = 42ull;
-  using vec                             = cuda::std::inplace_vector<T, max_capacity>;
-  const cuda::std::array<T, 6> expected = {T(0), T(1), T(2), T(3), T(4), T(T(5))};
+  constexpr size_t max_capacity         = 6ull;
+  using inplace_vector                  = cuda::std::inplace_vector<T, max_capacity>;
+  const cuda::std::array<T, 6> expected = {T(0), T(1), T(2), T(3), T(4), T(5)};
+
+  { // inplace_vector<T, N>::emplace(iter, args...)
+    inplace_vector vec = {T(0), T(1), T(2), T(4), T(5)};
+    const auto res     = vec.emplace(vec.begin() + 3, 3);
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == vec.begin() + 3);
+  }
 
-  {
-    vec emplace             = {T(0), T(1), T(2), T(4), T(T(5))};
-    const auto res_emplaced = emplace.emplace(emplace.begin() + 3, 3);
-    static_assert(cuda::std::is_same<decltype(res_emplaced), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(emplace.begin(), emplace.end(), expected.begin(), expected.end()));
-    assert(res_emplaced == emplace.begin() + 3);
-
-    vec emplace_const            = {T(0), T(1), T(2), T(4), T(T(5))};
-    const auto res_emplace_const = emplace_const.emplace(emplace_const.cbegin() + 3, 3);
-    static_assert(cuda::std::is_same<decltype(res_emplace_const), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(emplace_const.begin(), emplace_const.end(), expected.begin(), expected.end()));
-    assert(res_emplace_const == emplace_const.cbegin() + 3);
-
-    vec emplace_back        = {T(0), T(1), T(2), T(3), T(4)};
-    auto&& res_emplace_back = emplace_back.emplace_back(5);
-    static_assert(cuda::std::is_same<decltype(res_emplace_back), typename vec::reference>::value, "");
-    assert(cuda::std::equal(emplace_back.begin(), emplace_back.end(), expected.begin(), expected.end()));
-    assert(res_emplace_back == T(5));
-    res_emplace_back = T(6);
-    assert(res_emplace_back == T(6));
-
-    vec push_back_lvalue        = {T(0), T(1), T(2), T(3), T(4)};
-    const T to_be_pushed        = 5;
-    auto&& res_push_back_lvalue = push_back_lvalue.push_back(to_be_pushed);
-    static_assert(cuda::std::is_same<decltype(res_push_back_lvalue), typename vec::reference>::value, "");
-    assert(cuda::std::equal(push_back_lvalue.begin(), push_back_lvalue.end(), expected.begin(), expected.end()));
-    assert(res_push_back_lvalue == T(5));
-    res_push_back_lvalue = T(6);
-    assert(res_push_back_lvalue == T(6));
-
-    vec push_back_rvalue        = {T(0), T(1), T(2), T(3), T(4)};
-    auto&& res_push_back_rvalue = push_back_rvalue.push_back(T(5));
-    static_assert(cuda::std::is_same<decltype(res_push_back_rvalue), typename vec::reference>::value, "");
-    assert(cuda::std::equal(push_back_rvalue.begin(), push_back_rvalue.end(), expected.begin(), expected.end()));
-    assert(res_push_back_rvalue == T(5));
-    res_push_back_rvalue = T(6);
-    assert(res_push_back_rvalue == T(6));
+  { // inplace_vector<T, N>::emplace(const_iter, args...)
+    inplace_vector vec = {T(0), T(1), T(2), T(4), T(5)};
+    const auto res     = vec.emplace(vec.cbegin() + 3, 3);
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == vec.cbegin() + 3);
   }
 
-  {
-    vec emplace_back      = {T(0), T(1), T(2), T(3), T(4)};
-    auto res_emplace_back = emplace_back.try_emplace_back(5);
-    static_assert(cuda::std::is_same<decltype(res_emplace_back), typename vec::pointer>::value, "");
-    assert(cuda::std::equal(emplace_back.begin(), emplace_back.end(), expected.begin(), expected.end()));
-    assert(*res_emplace_back == T(5));
-    *res_emplace_back = T(6);
-    assert(*res_emplace_back == T(6));
-
-    vec push_back_lvalue      = {T(0), T(1), T(2), T(3), T(4)};
-    const T to_be_pushed      = 5;
-    auto res_push_back_lvalue = push_back_lvalue.try_push_back(to_be_pushed);
-    static_assert(cuda::std::is_same<decltype(res_push_back_lvalue), typename vec::pointer>::value, "");
-    assert(cuda::std::equal(push_back_lvalue.begin(), push_back_lvalue.end(), expected.begin(), expected.end()));
-    assert(*res_push_back_lvalue == T(5));
-    *res_push_back_lvalue = T(6);
-    assert(*res_push_back_lvalue == T(6));
-
-    vec push_back_rvalue      = {T(0), T(1), T(2), T(3), T(4)};
-    auto res_push_back_rvalue = push_back_rvalue.try_push_back(T(5));
-    static_assert(cuda::std::is_same<decltype(res_push_back_rvalue), typename vec::pointer>::value, "");
-    assert(cuda::std::equal(push_back_rvalue.begin(), push_back_rvalue.end(), expected.begin(), expected.end()));
-    assert(*res_push_back_rvalue == T(5));
-    *res_push_back_rvalue = T(6);
-    assert(*res_push_back_rvalue == T(6));
+  { // inplace_vector<T, N>::emplace_back(args...)
+    inplace_vector vec = {T(0), T(1), T(2), T(3), T(4)};
+    auto&& res         = vec.emplace_back(5);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::reference>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == T(5));
+    res = T(6);
+    assert(res == T(6));
   }
 
-  {
-    vec emplace_back        = {T(0), T(1), T(2), T(3), T(4)};
-    auto&& res_emplace_back = emplace_back.unchecked_emplace_back(5);
-    static_assert(cuda::std::is_same<decltype(res_emplace_back), typename vec::reference>::value, "");
-    assert(cuda::std::equal(emplace_back.begin(), emplace_back.end(), expected.begin(), expected.end()));
-    assert(res_emplace_back == T(5));
-    res_emplace_back = T(6);
-    assert(res_emplace_back == T(6));
-
-    vec push_back_lvalue        = {T(0), T(1), T(2), T(3), T(4)};
-    const T to_be_pushed        = 5;
-    auto&& res_push_back_lvalue = push_back_lvalue.unchecked_push_back(to_be_pushed);
-    static_assert(cuda::std::is_same<decltype(res_push_back_lvalue), typename vec::reference>::value, "");
-    assert(cuda::std::equal(push_back_lvalue.begin(), push_back_lvalue.end(), expected.begin(), expected.end()));
-    assert(res_push_back_lvalue == T(5));
-    res_push_back_lvalue = T(6);
-    assert(res_push_back_lvalue == T(6));
-
-    vec push_back_rvalue        = {T(0), T(1), T(2), T(3), T(4)};
-    auto&& res_push_back_rvalue = push_back_rvalue.unchecked_push_back(T(5));
-    static_assert(cuda::std::is_same<decltype(res_push_back_rvalue), typename vec::reference>::value, "");
-    assert(cuda::std::equal(push_back_rvalue.begin(), push_back_rvalue.end(), expected.begin(), expected.end()));
-    assert(res_push_back_rvalue == T(5));
-    res_push_back_rvalue = T(6);
-    assert(res_push_back_rvalue == T(6));
+  { // inplace_vector<T, N>::push_back(const T&)
+    const T to_be_pushed = 5;
+    inplace_vector vec   = {T(0), T(1), T(2), T(3), T(4)};
+    auto&& res           = vec.push_back(to_be_pushed);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::reference>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == T(5));
+    res = T(6);
+    assert(res == T(6));
   }
 
-  // try_emplace and friends return nullptr when out of capacity
-  using empty_vec = cuda::std::inplace_vector<T, 0>;
-  {
-    empty_vec emplace_back{};
-    auto res_emplace_back = emplace_back.try_emplace_back(5);
-    static_assert(cuda::std::is_same<decltype(res_emplace_back), typename vec::pointer>::value, "");
-    assert(emplace_back.empty());
-    assert(res_emplace_back == nullptr);
-
-    empty_vec push_back_lvalue{};
-    const T to_be_pushed      = 5;
-    auto res_push_back_lvalue = push_back_lvalue.try_push_back(to_be_pushed);
-    static_assert(cuda::std::is_same<decltype(res_push_back_lvalue), typename vec::pointer>::value, "");
-    assert(push_back_lvalue.empty());
-    assert(res_push_back_lvalue == nullptr);
-
-    empty_vec push_back_rvalue{};
-    auto res_push_back_rvalue = push_back_rvalue.try_push_back(T(5));
-    static_assert(cuda::std::is_same<decltype(res_push_back_rvalue), typename vec::pointer>::value, "");
-    assert(push_back_rvalue.empty());
-    assert(res_push_back_rvalue == nullptr);
+  { // inplace_vector<T, N>::push_back(T&&)
+    inplace_vector vec = {T(0), T(1), T(2), T(3), T(4)};
+    auto&& res         = vec.push_back(T(5));
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::reference>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == T(5));
+    res = T(6);
+    assert(res == T(6));
   }
 
-  using small_vec = cuda::std::inplace_vector<T, 5>;
-  {
-    small_vec emplace_back = {T(0), T(1), T(2), T(3), T(4)};
-    auto res_emplace_back  = emplace_back.try_emplace_back(5);
-    static_assert(cuda::std::is_same<decltype(res_emplace_back), typename vec::pointer>::value, "");
-    assert(cuda::std::equal(emplace_back.begin(), emplace_back.end(), expected.begin()));
-    assert(res_emplace_back == nullptr);
-
-    small_vec push_back_lvalue = {T(0), T(1), T(2), T(3), T(4)};
-    const T to_be_pushed       = 5;
-    auto res_push_back_lvalue  = push_back_lvalue.try_push_back(to_be_pushed);
-    static_assert(cuda::std::is_same<decltype(res_push_back_lvalue), typename vec::pointer>::value, "");
-    assert(cuda::std::equal(push_back_lvalue.begin(), push_back_lvalue.end(), expected.begin()));
-    assert(res_push_back_lvalue == nullptr);
-
-    small_vec push_back_rvalue = {T(0), T(1), T(2), T(3), T(4)};
-    auto res_push_back_rvalue  = push_back_rvalue.try_push_back(T(5));
-    static_assert(cuda::std::is_same<decltype(res_push_back_rvalue), typename vec::pointer>::value, "");
-    assert(cuda::std::equal(push_back_rvalue.begin(), push_back_rvalue.end(), expected.begin()));
-    assert(res_push_back_rvalue == nullptr);
+  { // inplace_vector<T, 0>::try_emplace_back(args...)
+    cuda::std::inplace_vector<T, 0> vec{};
+    auto res = vec.try_emplace_back(5);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::pointer>::value, "");
+    assert(vec.empty());
+    assert(res == nullptr);
+  }
+
+  { // inplace_vector<T, N>::try_emplace_back(args...)
+    inplace_vector vec = {T(0), T(1), T(2), T(3), T(4)};
+    auto res           = vec.try_emplace_back(5);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::pointer>::value, "");
+    assert(equal_range(vec, expected));
+    assert(*res == T(5));
+    *res = T(6);
+    assert(*res == T(6));
+  }
+
+  { // inplace_vector<T, N>::try_emplace_back(args...), at capacity
+    inplace_vector vec = {T(0), T(1), T(2), T(3), T(4), T(5)};
+    auto res           = vec.try_emplace_back(6);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::pointer>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == nullptr);
+  }
+
+  { // inplace_vector<T, 0>::try_push_back(const T&)
+    const T to_be_pushed = 5;
+    cuda::std::inplace_vector<T, 0> vec{};
+    auto res = vec.try_push_back(to_be_pushed);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::pointer>::value, "");
+    assert(vec.empty());
+    assert(res == nullptr);
+  }
+
+  { // inplace_vector<T, N>::try_push_back(const T&)
+    const T to_be_pushed = 5;
+    inplace_vector vec   = {T(0), T(1), T(2), T(3), T(4)};
+    auto res             = vec.try_push_back(to_be_pushed);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::pointer>::value, "");
+    assert(equal_range(vec, expected));
+    assert(*res == T(5));
+    *res = T(6);
+    assert(*res == T(6));
+  }
+
+  { // inplace_vector<T, N>::try_push_back(const T&), at capacity
+    const T to_be_pushed = 6;
+    inplace_vector vec   = {T(0), T(1), T(2), T(3), T(4), T(5)};
+    auto res             = vec.try_push_back(to_be_pushed);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::pointer>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == nullptr);
+  }
+
+  { // inplace_vector<T, 0>::try_push_back(T&&)
+    cuda::std::inplace_vector<T, 0> vec{};
+    auto res = vec.try_push_back(5);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::pointer>::value, "");
+    assert(vec.empty());
+    assert(res == nullptr);
+  }
+
+  { // inplace_vector<T, N>::try_push_back(T&&)
+    inplace_vector vec = {T(0), T(1), T(2), T(3), T(4)};
+    auto res           = vec.try_push_back(T(5));
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::pointer>::value, "");
+    assert(equal_range(vec, expected));
+    assert(*res == T(5));
+    *res = T(6);
+    assert(*res == T(6));
+  }
+
+  { // inplace_vector<T, N>::try_push_back(T&&), at capacity
+    inplace_vector vec = {T(0), T(1), T(2), T(3), T(4), T(5)};
+    auto res           = vec.try_push_back(T(6));
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::pointer>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == nullptr);
+  }
+
+  { // inplace_vector<T, N>::unchecked_emplace_back(args...)
+    inplace_vector vec = {T(0), T(1), T(2), T(3), T(4)};
+    auto&& res         = vec.unchecked_emplace_back(5);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::reference>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == T(5));
+    res = T(6);
+    assert(res == T(6));
+  }
+
+  { // inplace_vector<T, N>::unchecked_push_back(const T&)
+    const T to_be_pushed = 5;
+    inplace_vector vec   = {T(0), T(1), T(2), T(3), T(4)};
+    auto&& res           = vec.unchecked_push_back(to_be_pushed);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::reference>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == T(5));
+    res = T(6);
+    assert(res == T(6));
+  }
+
+  { // inplace_vector<T, N>::unchecked_push_back(T&&)
+    inplace_vector vec = {T(0), T(1), T(2), T(3), T(4)};
+    auto&& res         = vec.unchecked_push_back(T(5));
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::reference>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == T(5));
+    res = T(6);
+    assert(res == T(6));
   }
 }
 
 __host__ __device__ constexpr bool test()
 {
   test<int>();
+  test<Trivial>();
 
   if (!cuda::std::__libcpp_is_constant_evaluated())
   {
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/insert.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/insert.pass.cpp
index 389dea12f0..d4b4367821 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/insert.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/insert.pass.cpp
@@ -29,188 +29,189 @@ _CCCL_DIAG_SUPPRESS_CLANG("-Wmissing-braces")
 _CCCL_DIAG_SUPPRESS_MSVC(5246)
 
 #if TEST_STD_VER >= 2017 && !defined(TEST_COMPILER_MSVC_2017)
-template <class T, class Range>
+template <class T, template <class, size_t> class Range>
 __host__ __device__ constexpr void test_range()
 {
   constexpr size_t max_capacity = 5ull;
-  using vec                     = cuda::std::inplace_vector<T, max_capacity>;
-  {
-    const cuda::std::array<T, 5> expected_insert_range = {T(0), T(42), T(3), T(1337), T(5)};
+  using inplace_vector          = cuda::std::inplace_vector<T, max_capacity>;
 
-    vec insert_range            = {T(0), T(5)};
-    const auto res_insert_range = insert_range.insert_range(insert_range.begin() + 1, Range{T(42), T(3), T(1337)});
-    static_assert(cuda::std::is_same<decltype(res_insert_range), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(
-      insert_range.begin(), insert_range.end(), expected_insert_range.begin(), expected_insert_range.end()));
-    assert(res_insert_range == insert_range.begin() + 1);
+  { // inplace_vector<T, 0>::insert_range(iter, range)
+    cuda::std::inplace_vector<T, 0> vec{};
+    const auto res = vec.insert_range(vec.begin(), Range<T, 0>{});
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(vec.empty());
+    assert(res == vec.begin());
+  }
 
-    vec insert_range_const = {T(0), T(5)};
-    const auto res_insert_range_const =
-      insert_range_const.insert_range(insert_range_const.cbegin() + 1, Range{T(42), T(3), T(1337)});
-    static_assert(cuda::std::is_same<decltype(res_insert_range_const), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(
-      insert_range_const.begin(), insert_range_const.end(), expected_insert_range.begin(), expected_insert_range.end()));
-    assert(res_insert_range_const == insert_range_const.cbegin() + 1);
+  { // inplace_vector<T, N>::insert_range(iter, range)
+    inplace_vector vec = {T(0), T(5)};
+    const auto res     = vec.insert_range(vec.begin() + 1, Range<T, 3>{T(42), T(3), T(1337)});
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, cuda::std::array<T, 5>{T(0), T(42), T(3), T(1337), T(5)}));
+    assert(res == vec.begin() + 1);
   }
 
-  {
-    const cuda::std::initializer_list<T> expected_append_range = {T(0), T(5), T(42), T(3), T(1337)};
-    vec append_range                                           = {T(0), T(5)};
-    append_range.append_range(Range{T(42), T(3), T(1337)});
-    assert(cuda::std::equal(
-      append_range.begin(), append_range.end(), expected_append_range.begin(), expected_append_range.end()));
-
-    Range try_input{T(42), T(3), T(1337)};
-    vec try_append_range      = {T(0), T(5)};
-    auto res_try_append_range = try_append_range.try_append_range(try_input);
-    static_assert(cuda::std::is_same<decltype(res_try_append_range), cuda::std::ranges::iterator_t<Range>>::value, "");
-    assert(cuda::std::equal(
-      try_append_range.begin(), try_append_range.end(), expected_append_range.begin(), expected_append_range.end()));
-    assert(res_try_append_range == try_input.end());
-
-    Range try_input_partial{T(3), T(1337), T(1)};
-    vec try_append_range_partial      = {T(0), T(5), T(42)};
-    auto res_try_append_range_partial = try_append_range_partial.try_append_range(try_input_partial);
-    static_assert(
-      cuda::std::is_same<decltype(res_try_append_range_partial), cuda::std::ranges::iterator_t<Range>>::value, "");
-    assert(cuda::std::equal(
-      try_append_range_partial.begin(),
-      try_append_range_partial.end(),
-      expected_append_range.begin(),
-      expected_append_range.end()));
-    assert(++res_try_append_range_partial == try_input_partial.end());
+  { // inplace_vector<T, 0>::insert_range(const iter, range)
+    cuda::std::inplace_vector<T, 0> vec{};
+    const auto res = vec.insert_range(vec.cbegin(), Range<T, 0>{});
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(vec.empty());
+    assert(res == vec.begin());
   }
-}
-#endif // TEST_STD_VER >= 2017 && !defined(TEST_COMPILER_MSVC_2017)
 
-template <class T>
-__host__ __device__ constexpr void test()
-{
-  constexpr size_t max_capacity = 42ull;
-  using vec                     = cuda::std::inplace_vector<T, max_capacity>;
+  { // inplace_vector<T, N>::insert_range(const_iter, range)
+    inplace_vector vec = {T(0), T(5)};
+    const auto res     = vec.insert_range(vec.cbegin() + 1, Range<T, 3>{T(42), T(3), T(1337)});
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, cuda::std::array<T, 5>{T(0), T(42), T(3), T(1337), T(5)}));
+    assert(res == vec.cbegin() + 1);
+  }
 
-  {
-    const cuda::std::initializer_list<T> expected_insert_value = {T(0), T(3), T(5)};
-    const T to_be_inserted                                     = 3;
-
-    vec insert_lvalue            = {T(0), T(5)};
-    const auto res_insert_lvalue = insert_lvalue.insert(insert_lvalue.begin() + 1, to_be_inserted);
-    static_assert(cuda::std::is_same<decltype(res_insert_lvalue), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(
-      insert_lvalue.begin(), insert_lvalue.end(), expected_insert_value.begin(), expected_insert_value.end()));
-    assert(res_insert_lvalue == insert_lvalue.begin() + 1);
-
-    vec insert_lvalue_const            = {T(0), T(5)};
-    const auto res_insert_lvalue_const = insert_lvalue_const.insert(insert_lvalue_const.cbegin() + 1, to_be_inserted);
-    static_assert(cuda::std::is_same<decltype(res_insert_lvalue_const), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(
-      insert_lvalue_const.begin(),
-      insert_lvalue_const.end(),
-      expected_insert_value.begin(),
-      expected_insert_value.end()));
-    assert(res_insert_lvalue_const == insert_lvalue_const.cbegin() + 1);
-
-    vec insert_rvalue            = {T(0), T(5)};
-    const auto res_insert_rvalue = insert_rvalue.insert(insert_rvalue.begin() + 1, 3);
-    static_assert(cuda::std::is_same<decltype(res_insert_rvalue), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(
-      insert_rvalue.begin(), insert_rvalue.end(), expected_insert_value.begin(), expected_insert_value.end()));
-    assert(res_insert_rvalue == insert_rvalue.begin() + 1);
-
-    vec insert_rvalue_const            = {T(0), T(5)};
-    const auto res_insert_rvalue_const = insert_rvalue_const.insert(insert_rvalue_const.cbegin() + 1, 3);
-    static_assert(cuda::std::is_same<decltype(res_insert_rvalue_const), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(
-      insert_rvalue_const.begin(),
-      insert_rvalue_const.end(),
-      expected_insert_value.begin(),
-      expected_insert_value.end()));
-    assert(res_insert_rvalue_const == insert_rvalue_const.cbegin() + 1);
+  { // inplace_vector<T, 0>::append_range(range)
+    cuda::std::inplace_vector<T, 0> vec{};
+    vec.append_range(Range<T, 0>{});
+    assert(vec.empty());
   }
 
-  {
-    using iter                                                = cpp17_input_iterator<const T*>;
-    const cuda::std::initializer_list<T> expected_insert_iter = {T(0), T(42), T(3), T(1337), T(5)};
-    const cuda::std::initializer_list<T> to_be_inserted       = {T(42), T(3), T(1337)};
-
-    vec insert_iter_range = {T(0), T(5)};
-    const auto res_insert_iter_range =
-      insert_iter_range.insert(insert_iter_range.begin() + 1, iter{to_be_inserted.begin()}, iter{to_be_inserted.end()});
-    static_assert(cuda::std::is_same<decltype(res_insert_iter_range), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(
-      insert_iter_range.begin(), insert_iter_range.end(), expected_insert_iter.begin(), expected_insert_iter.end()));
-    assert(res_insert_iter_range == insert_iter_range.begin() + 1);
-
-    vec insert_iter_range_const            = {T(0), T(5)};
-    const auto res_insert_iter_range_const = insert_iter_range_const.insert(
-      insert_iter_range_const.cbegin() + 1, iter{to_be_inserted.begin()}, iter{to_be_inserted.end()});
-    static_assert(cuda::std::is_same<decltype(res_insert_iter_range_const), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(
-      insert_iter_range_const.begin(),
-      insert_iter_range_const.end(),
-      expected_insert_iter.begin(),
-      expected_insert_iter.end()));
-    assert(res_insert_iter_range_const == insert_iter_range_const.cbegin() + 1);
+  { // inplace_vector<T, N>::append_range(range)
+    inplace_vector vec = {T(0), T(5)};
+    vec.append_range(Range<T, 3>{T(42), T(3), T(1337)});
+    assert(equal_range(vec, cuda::std::array<T, 5>{T(0), T(5), T(42), T(3), T(1337)}));
   }
 
-  {
-    const cuda::std::initializer_list<T> expected_insert_iter = {T(0), T(42), T(3), T(1337), T(5)};
-    const cuda::std::initializer_list<T> to_be_inserted       = {T(42), T(3), T(1337)};
-
-    vec insert_iter_range = {T(0), T(5)};
-    const auto res_insert_iter_range =
-      insert_iter_range.insert(insert_iter_range.begin() + 1, to_be_inserted.begin(), to_be_inserted.end());
-    static_assert(cuda::std::is_same<decltype(res_insert_iter_range), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(
-      insert_iter_range.begin(), insert_iter_range.end(), expected_insert_iter.begin(), expected_insert_iter.end()));
-    assert(res_insert_iter_range == insert_iter_range.begin() + 1);
-
-    vec insert_iter_range_const            = {T(0), T(5)};
-    const auto res_insert_iter_range_const = insert_iter_range_const.insert(
-      insert_iter_range_const.cbegin() + 1, to_be_inserted.begin(), to_be_inserted.end());
-    static_assert(cuda::std::is_same<decltype(res_insert_iter_range_const), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(
-      insert_iter_range_const.begin(),
-      insert_iter_range_const.end(),
-      expected_insert_iter.begin(),
-      expected_insert_iter.end()));
-    assert(res_insert_iter_range_const == insert_iter_range_const.cbegin() + 1);
+  { // inplace_vector<T, 0>::try_append_range(range)
+    Range<T, 3> input{T(42), T(3), T(1337)};
+    cuda::std::inplace_vector<T, 0> vec{};
+    auto res = vec.try_append_range(input);
+    static_assert(cuda::std::is_same<decltype(res), cuda::std::ranges::iterator_t<Range<T, 3>>>::value, "");
+    assert(vec.empty());
+    assert(res == input.begin());
   }
 
-  {
-    const cuda::std::initializer_list<T> expected_insert_iter = {T(0), T(42), T(3), T(1337), T(5)};
-    const cuda::std::initializer_list<T> to_be_inserted       = {T(42), T(3), T(1337)};
-
-    vec insert_initializer            = {T(0), T(5)};
-    const auto res_insert_initializer = insert_initializer.insert(insert_initializer.begin() + 1, to_be_inserted);
-    static_assert(cuda::std::is_same<decltype(res_insert_initializer), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(
-      insert_initializer.begin(), insert_initializer.end(), expected_insert_iter.begin(), expected_insert_iter.end()));
-    assert(res_insert_initializer == insert_initializer.begin() + 1);
-
-    vec insert_initializer_const = {T(0), T(5)};
-    const auto res_insert_initializer_const =
-      insert_initializer_const.insert(insert_initializer_const.cbegin() + 1, to_be_inserted);
-    static_assert(cuda::std::is_same<decltype(res_insert_initializer_const), const typename vec::iterator>::value, "");
-    assert(cuda::std::equal(
-      insert_initializer_const.begin(),
-      insert_initializer_const.end(),
-      expected_insert_iter.begin(),
-      expected_insert_iter.end()));
-    assert(res_insert_initializer_const == insert_initializer_const.cbegin() + 1);
+  { // inplace_vector<T, N>::try_append_range(range)
+    Range<T, 3> input{T(42), T(3), T(1337)};
+    inplace_vector vec{T(0), T(5)};
+    auto res = vec.try_append_range(input);
+    static_assert(cuda::std::is_same<decltype(res), cuda::std::ranges::iterator_t<Range<T, 3>>>::value, "");
+    assert(equal_range(vec, cuda::std::array<T, 5>{T(0), T(5), T(42), T(3), T(1337)}));
+    assert(res == input.end());
+  }
+
+  { // inplace_vector<T, N>::try_append_range(range), beyond capacity
+    Range<T, 4> input{T(42), T(3), T(1337), T(1)};
+    inplace_vector vec{T(0), T(5)};
+    auto res = vec.try_append_range(input);
+    static_assert(cuda::std::is_same<decltype(res), cuda::std::ranges::iterator_t<Range<T, 3>>>::value, "");
+    assert(equal_range(vec, cuda::std::array<T, 5>{T(0), T(5), T(42), T(3), T(1337)}));
+    assert(++res == input.end());
+  }
+}
+#endif // TEST_STD_VER >= 2017 && !defined(TEST_COMPILER_MSVC_2017)
+
+template <class T>
+__host__ __device__ constexpr void test()
+{
+  constexpr size_t max_capacity = 42ull;
+  using inplace_vector          = cuda::std::inplace_vector<T, max_capacity>;
+
+  { // inplace_vector<T, N>::insert(iter, const T&)
+    const T to_be_inserted = 3;
+    inplace_vector vec     = {T(0), T(5)};
+    const auto res         = vec.insert(vec.begin() + 1, to_be_inserted);
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, cuda::std::array<T, 3>{T(0), T(3), T(5)}));
+    assert(res == vec.begin() + 1);
+  }
+
+  { // inplace_vector<T, N>::insert(const_iter, const T&)
+    const T to_be_inserted = 3;
+    inplace_vector vec     = {T(0), T(5)};
+    const auto res         = vec.insert(vec.cbegin() + 1, to_be_inserted);
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, cuda::std::array<T, 3>{T(0), T(3), T(5)}));
+    assert(res == vec.begin() + 1);
+  }
+
+  { // inplace_vector<T, N>::insert(iter, T&&)
+    inplace_vector vec = {T(0), T(5)};
+    const auto res     = vec.insert(vec.begin() + 1, T(3));
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, cuda::std::array<T, 3>{T(0), T(3), T(5)}));
+    assert(res == vec.begin() + 1);
+  }
+
+  { // inplace_vector<T, N>::insert(const_iter, T&&)
+    inplace_vector vec = {T(0), T(5)};
+    const auto res     = vec.insert(vec.cbegin() + 1, T(3));
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, cuda::std::array<T, 3>{T(0), T(3), T(5)}));
+    assert(res == vec.begin() + 1);
+  }
+
+  const cuda::std::array<T, 5> expected{T(0), T(42), T(3), T(1337), T(5)};
+  const cuda::std::initializer_list<T> input{T(42), T(3), T(1337)};
+  { // inplace_vector<T, N>::insert(iter, iter, iter), input iterators
+    using iter         = cpp17_input_iterator<const T*>;
+    inplace_vector vec = {T(0), T(5)};
+    const auto res     = vec.insert(vec.begin() + 1, iter{input.begin()}, iter{input.end()});
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == vec.begin() + 1);
+  }
+
+  { // inplace_vector<T, N>::insert(const_iter, iter, iter), input iterators
+    using iter         = cpp17_input_iterator<const T*>;
+    inplace_vector vec = {T(0), T(5)};
+    const auto res     = vec.insert(vec.cbegin() + 1, iter{input.begin()}, iter{input.end()});
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == vec.cbegin() + 1);
+  }
+
+  { // inplace_vector<T, N>::insert(iter, iter, iter), forward iterators
+    inplace_vector vec = {T(0), T(5)};
+    const auto res     = vec.insert(vec.begin() + 1, input.begin(), input.end());
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == vec.begin() + 1);
+  }
+
+  { // inplace_vector<T, N>::insert(const_iter, iter, iter), forward iterators
+    inplace_vector vec = {T(0), T(5)};
+    const auto res     = vec.insert(vec.cbegin() + 1, input.begin(), input.end());
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == vec.cbegin() + 1);
+  }
+
+  { // inplace_vector<T, N>::insert(iter, init_list)
+    inplace_vector vec = {T(0), T(5)};
+    const auto res     = vec.insert(vec.begin() + 1, input);
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == vec.begin() + 1);
+  }
+
+  { // inplace_vector<T, N>::insert(const_iter, init_list)
+    inplace_vector vec = {T(0), T(5)};
+    const auto res     = vec.insert(vec.cbegin() + 1, input);
+    static_assert(cuda::std::is_same<decltype(res), const typename inplace_vector::iterator>::value, "");
+    assert(equal_range(vec, expected));
+    assert(res == vec.cbegin() + 1);
   }
 
 #if TEST_STD_VER >= 2017 && !defined(TEST_COMPILER_MSVC_2017)
-  test_range<T, input_range<T, 3>>();
-  test_range<T, uncommon_range<T, 3>>();
-  test_range<T, sized_uncommon_range<T, 3>>();
-  test_range<T, cuda::std::array<T, 3>>();
+  test_range<T, input_range>();
+  test_range<T, uncommon_range>();
+  test_range<T, sized_uncommon_range>();
+  test_range<T, cuda::std::array>();
 #endif // TEST_STD_VER >= 2017 && !defined(TEST_COMPILER_MSVC_2017)
 }
 
 __host__ __device__ constexpr bool test()
 {
   test<int>();
+  test<Trivial>();
 
   if (!cuda::std::__libcpp_is_constant_evaluated())
   {
@@ -225,8 +226,8 @@ __host__ __device__ constexpr bool test()
 #ifndef TEST_HAS_NO_EXCEPTIONS
 void test_exceptions()
 { // insert throws std::bad_alloc
-  using vec = cuda::std::inplace_vector<int, 2>;
-  vec too_small{1, 2};
+  using inplace_vector = cuda::std::inplace_vector<int, 2>;
+  inplace_vector too_small{1, 2};
 
   try
   {
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/iterators.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/iterators.pass.cpp
index 493497c771..740a4eaf05 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/iterators.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/iterators.pass.cpp
@@ -24,62 +24,66 @@
 template <class T>
 __host__ __device__ constexpr void test()
 {
-  using vec = cuda::std::inplace_vector<T, 42>;
-  vec range{T(1), T(1337), T(42), T(12), T(0), T(-1)};
-  const vec const_range{T(0), T(42), T(1337), T(42), T(5), T(-42)};
+  using inplace_vector = cuda::std::inplace_vector<T, 42>;
+  inplace_vector range{T(1), T(1337), T(42), T(12), T(0), T(-1)};
+  const inplace_vector const_range{T(0), T(42), T(1337), T(42), T(5), T(-42)};
 
   const auto begin = range.begin();
-  static_assert(cuda::std::is_same<decltype(begin), const typename vec::iterator>::value, "");
+  static_assert(cuda::std::is_same<decltype(begin), const typename inplace_vector::iterator>::value, "");
   assert(*begin == T(1));
 
   const auto cbegin = range.cbegin();
-  static_assert(cuda::std::is_same<decltype(cbegin), const typename vec::const_iterator>::value, "");
+  static_assert(cuda::std::is_same<decltype(cbegin), const typename inplace_vector::const_iterator>::value, "");
   assert(*cbegin == T(1));
 
   const auto const_begin = const_range.begin();
-  static_assert(cuda::std::is_same<decltype(const_begin), const typename vec::const_iterator>::value, "");
+  static_assert(cuda::std::is_same<decltype(const_begin), const typename inplace_vector::const_iterator>::value, "");
   assert(*const_begin == T(0));
 
   const auto end = range.end();
-  static_assert(cuda::std::is_same<decltype(end), const typename vec::iterator>::value, "");
+  static_assert(cuda::std::is_same<decltype(end), const typename inplace_vector::iterator>::value, "");
   assert(*cuda::std::prev(end) == T(-1));
 
   const auto cend = range.cend();
-  static_assert(cuda::std::is_same<decltype(cend), const typename vec::const_iterator>::value, "");
+  static_assert(cuda::std::is_same<decltype(cend), const typename inplace_vector::const_iterator>::value, "");
   assert(*cuda::std::prev(cend) == T(-1));
 
   const auto const_end = const_range.end();
-  static_assert(cuda::std::is_same<decltype(const_end), const typename vec::const_iterator>::value, "");
+  static_assert(cuda::std::is_same<decltype(const_end), const typename inplace_vector::const_iterator>::value, "");
   assert(*cuda::std::prev(const_end) == T(-42));
 
   const auto rbegin = range.rbegin();
-  static_assert(cuda::std::is_same<decltype(rbegin), const typename vec::reverse_iterator>::value, "");
+  static_assert(cuda::std::is_same<decltype(rbegin), const typename inplace_vector::reverse_iterator>::value, "");
   assert(*rbegin == T(-1));
 
   const auto crbegin = range.crbegin();
-  static_assert(cuda::std::is_same<decltype(crbegin), const typename vec::const_reverse_iterator>::value, "");
+  static_assert(cuda::std::is_same<decltype(crbegin), const typename inplace_vector::const_reverse_iterator>::value,
+                "");
   assert(*crbegin == T(-1));
 
   const auto const_rbegin = const_range.rbegin();
-  static_assert(cuda::std::is_same<decltype(const_rbegin), const typename vec::const_reverse_iterator>::value, "");
+  static_assert(
+    cuda::std::is_same<decltype(const_rbegin), const typename inplace_vector::const_reverse_iterator>::value, "");
   assert(*const_rbegin == T(-42));
 
   const auto rend = range.rend();
-  static_assert(cuda::std::is_same<decltype(rend), const typename vec::reverse_iterator>::value, "");
+  static_assert(cuda::std::is_same<decltype(rend), const typename inplace_vector::reverse_iterator>::value, "");
   assert(*cuda::std::prev(rend) == T(1));
 
   const auto crend = range.crend();
-  static_assert(cuda::std::is_same<decltype(crend), const typename vec::const_reverse_iterator>::value, "");
+  static_assert(cuda::std::is_same<decltype(crend), const typename inplace_vector::const_reverse_iterator>::value, "");
   assert(*cuda::std::prev(crend) == T(1));
 
   const auto const_rend = const_range.rend();
-  static_assert(cuda::std::is_same<decltype(const_rend), const typename vec::const_reverse_iterator>::value, "");
+  static_assert(cuda::std::is_same<decltype(const_rend), const typename inplace_vector::const_reverse_iterator>::value,
+                "");
   assert(*cuda::std::prev(const_rend) == T(0));
 }
 
 __host__ __device__ constexpr bool test()
 {
   test<int>();
+  test<Trivial>();
 
   if (!cuda::std::__libcpp_is_constant_evaluated())
   {
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/properties.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/properties.pass.cpp
index 25655ed729..9f6e434da6 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/properties.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/properties.pass.cpp
@@ -60,22 +60,24 @@ __host__ __device__ void test()
     sizeof(cuda::std::inplace_vector<char, uint32_t_max + 1>) == uint32_t_max + 1 + sizeof(cuda::std::uint64_t), "");
 
   // Check the type aliases
-  using vec = cuda::std::inplace_vector<int, 42>;
-  static_assert(cuda::std::is_same<int, typename vec::value_type>::value, "");
-  static_assert(cuda::std::is_same<cuda::std::size_t, typename vec::size_type>::value, "");
-  static_assert(cuda::std::is_same<cuda::std::ptrdiff_t, typename vec::difference_type>::value, "");
-  static_assert(cuda::std::is_same<int*, typename vec::pointer>::value, "");
-  static_assert(cuda::std::is_same<const int*, typename vec::const_pointer>::value, "");
-  static_assert(cuda::std::is_same<int&, typename vec::reference>::value, "");
-  static_assert(cuda::std::is_same<const int&, typename vec::const_reference>::value, "");
-  static_assert(cuda::std::is_same<int*, typename vec::iterator>::value, "");
-  static_assert(cuda::std::is_same<const int*, typename vec::const_iterator>::value, "");
-  static_assert(cuda::std::is_same<cuda::std::reverse_iterator<int*>, typename vec::reverse_iterator>::value, "");
+  using inplace_vector = cuda::std::inplace_vector<int, 42>;
+  static_assert(cuda::std::is_same<int, typename inplace_vector::value_type>::value, "");
+  static_assert(cuda::std::is_same<cuda::std::size_t, typename inplace_vector::size_type>::value, "");
+  static_assert(cuda::std::is_same<cuda::std::ptrdiff_t, typename inplace_vector::difference_type>::value, "");
+  static_assert(cuda::std::is_same<int*, typename inplace_vector::pointer>::value, "");
+  static_assert(cuda::std::is_same<const int*, typename inplace_vector::const_pointer>::value, "");
+  static_assert(cuda::std::is_same<int&, typename inplace_vector::reference>::value, "");
+  static_assert(cuda::std::is_same<const int&, typename inplace_vector::const_reference>::value, "");
+  static_assert(cuda::std::is_same<int*, typename inplace_vector::iterator>::value, "");
+  static_assert(cuda::std::is_same<const int*, typename inplace_vector::const_iterator>::value, "");
+  static_assert(cuda::std::is_same<cuda::std::reverse_iterator<int*>, typename inplace_vector::reverse_iterator>::value,
+                "");
   static_assert(
-    cuda::std::is_same<cuda::std::reverse_iterator<const int*>, typename vec::const_reverse_iterator>::value, "");
+    cuda::std::is_same<cuda::std::reverse_iterator<const int*>, typename inplace_vector::const_reverse_iterator>::value,
+    "");
 
 #if TEST_STD_VER >= 2017 && !defined(TEST_COMPILER_MSVC_2017)
-  static_assert(cuda::std::ranges::contiguous_range<vec>);
+  static_assert(cuda::std::ranges::contiguous_range<inplace_vector>);
 #endif // TEST_STD_VER >= 2017 && !defined(TEST_COMPILER_MSVC_2017)
 }
 
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/resize.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/resize.pass.cpp
index 72ed94029a..3b5994708b 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/resize.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/resize.pass.cpp
@@ -24,6 +24,74 @@
 #  include <stdexcept>
 #endif // !TEST_HAS_NO_EXCEPTIONS
 
+template <class T>
+__host__ __device__ constexpr void test_resize()
+{
+  constexpr size_t max_capacity = 42ull;
+  using inplace_vector          = cuda::std::inplace_vector<T, max_capacity>;
+
+  { // inplace_vector<T, 0>::resize with a size
+    cuda::std::inplace_vector<T, 0> vec{};
+    vec.resize(0);
+    assert(vec.empty());
+  }
+
+  { // inplace_vector<T, 0>::resize with a size and value
+    cuda::std::inplace_vector<T, 0> vec{};
+    vec.resize(0, T{42});
+    assert(vec.empty());
+  }
+
+  { // inplace_vector<T, N>::resize with a size, shrinking
+    inplace_vector vec{T(1), T(1337), T(42), T(12), T(0), T(-1)};
+    vec.resize(1);
+    assert(equal_range(vec, cuda::std::array<T, 1>{T(1)}));
+  }
+
+  { // inplace_vector<T, N>::resize with a size and value, shrinking
+    inplace_vector vec{T(1), T(1337), T(42), T(12), T(0), T(-1)};
+    vec.resize(1, T(5));
+    assert(equal_range(vec, cuda::std::array<T, 1>{T(1)}));
+  }
+
+  { // inplace_vector<T, N>::resize with a size, growing, new elements are value initialized
+    inplace_vector vec{T(1), T(1337), T(42), T(12), T(0), T(-1)};
+    vec.resize(8);
+    assert(equal_range(vec, cuda::std::array<T, 8>{T(1), T(1337), T(42), T(12), T(0), T(-1), T(0), T(0)}));
+  }
+
+  { // inplace_vector<T, N>::resize with a size and value, growing, new elements are copied
+    inplace_vector vec{T(1), T(1337), T(42), T(12), T(0), T(-1)};
+    vec.resize(8, T(5));
+    assert(equal_range(vec, cuda::std::array<T, 8>{T(1), T(1337), T(42), T(12), T(0), T(-1), T(5), T(5)}));
+  }
+}
+
+template <class T>
+__host__ __device__ constexpr void test_clear()
+{
+  constexpr size_t max_capacity = 42ull;
+  using inplace_vector          = cuda::std::inplace_vector<T, max_capacity>;
+
+  { // inplace_vector<T, 0>::clear
+    cuda::std::inplace_vector<T, 0> vec{};
+    vec.clear();
+    assert(vec.empty());
+  }
+
+  { // inplace_vector<T, N>::clear, from empty
+    inplace_vector vec{};
+    vec.clear();
+    assert(vec.empty());
+  }
+
+  { // inplace_vector<T, N>::clear
+    inplace_vector vec{T(1), T(1337), T(42), T(12), T(0), T(-1)};
+    vec.clear();
+    assert(vec.empty());
+  }
+}
+
 struct is_one
 {
   template <class T>
@@ -34,102 +102,134 @@ struct is_one
 };
 
 template <class T>
-__host__ __device__ constexpr void test()
+__host__ __device__ constexpr void test_pop_back()
 {
   constexpr size_t max_capacity = 42ull;
-  using vec                     = cuda::std::inplace_vector<T, max_capacity>;
+  using inplace_vector          = cuda::std::inplace_vector<T, max_capacity>;
 
-  {
-    cuda::std::initializer_list<T> expected{T(1)};
-    vec resize_shrink{T(1), T(1337), T(42), T(12), T(0), T(-1)};
-    resize_shrink.resize(1);
-    assert(cuda::std::equal(resize_shrink.begin(), resize_shrink.end(), expected.begin(), expected.end()));
+  { // inplace_vector<T, N>::pop_back
+    inplace_vector vec{T(1), T(1337), T(42), T(12), T(0), T(-1)};
+    vec.pop_back();
+    assert(equal_range(vec, cuda::std::array<T, 5>{T(1), T(1337), T(42), T(12), T(0)}));
+  }
+}
+
+template <class T>
+__host__ __device__ constexpr void test_erase()
+{
+  constexpr size_t max_capacity = 42ull;
+  using inplace_vector          = cuda::std::inplace_vector<T, max_capacity>;
+
+  { // inplace_vector<T, N>::erase(iter)
+    inplace_vector vec{T(1), T(1337), T(42), T(12), T(0), T(-1)};
+    auto res = vec.erase(vec.begin() + 1);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::iterator>::value, "");
+    assert(*res == T(42));
+    assert(equal_range(vec, cuda::std::array<T, 5>{T(1), T(42), T(12), T(0), T(-1)}));
   }
 
-  {
-    cuda::std::initializer_list<T> expected{T(1)};
-    vec resize_value_shrink{T(1), T(1337), T(42), T(12), T(0), T(-1)};
-    resize_value_shrink.resize(1, T(5));
-    assert(cuda::std::equal(resize_value_shrink.begin(), resize_value_shrink.end(), expected.begin(), expected.end()));
+  { // inplace_vector<T, N>::erase(iter, iter), iterators are equal
+    inplace_vector vec{T(1), T(1337), T(42), T(12), T(0), T(-1)};
+    auto res = vec.erase(vec.begin() + 1, vec.begin() + 1);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::iterator>::value, "");
+    assert(*res == T(1337));
+    assert(equal_range(vec, cuda::std::array<T, 6>{T(1), T(1337), T(42), T(12), T(0), T(-1)}));
   }
 
-  {
-    cuda::std::initializer_list<T> expected{T(1), T(1337), T(42), T(12), T(0), T(-1), T(0), T(0), T(0)};
-    vec resize_grow{T(1), T(1337), T(42), T(12), T(0), T(-1)};
-    resize_grow.resize(9);
-    assert(cuda::std::equal(resize_grow.begin(), resize_grow.end(), expected.begin(), expected.end()));
+  { // inplace_vector<T, N>::erase(iter, iter)
+    inplace_vector vec{T(1), T(1337), T(42), T(12), T(0), T(-1)};
+    auto res = vec.erase(vec.begin() + 1, vec.begin() + 3);
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::iterator>::value, "");
+    assert(*res == T(12));
+    assert(equal_range(vec, cuda::std::array<T, 4>{T(1), T(12), T(0), T(-1)}));
   }
 
-  {
-    cuda::std::initializer_list<T> expected{T(1), T(1337), T(42), T(12), T(0), T(-1), T(5), T(5), T(5)};
-    vec resize_value_grow{T(1), T(1337), T(42), T(12), T(0), T(-1)};
-    resize_value_grow.resize(9, T(5));
-    assert(cuda::std::equal(resize_value_grow.begin(), resize_value_grow.end(), expected.begin(), expected.end()));
+  { // erase(inplace_vector<T, 0>, value)
+    cuda::std::inplace_vector<T, 0> vec{};
+    auto res = erase(vec, T(1));
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::size_type>::value, "");
+    assert(res == 0);
+    assert(vec.empty());
   }
 
-  {
-    vec clear{T(1), T(1337), T(42), T(12), T(0), T(-1)};
-    clear.clear();
-    assert(clear.empty());
+  { // erase_if(inplace_vector<T, 0>, pred)
+    cuda::std::inplace_vector<T, 0> vec{};
+    auto res = erase_if(vec, is_one{});
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::size_type>::value, "");
+    assert(res == 0);
+    assert(vec.empty());
   }
 
-  {
-    cuda::std::initializer_list<T> expected{T(1), T(1337), T(42), T(12), T(0)};
-    vec pop_back{T(1), T(1337), T(42), T(12), T(0), T(-1)};
-    pop_back.pop_back();
-    assert(cuda::std::equal(pop_back.begin(), pop_back.end(), expected.begin(), expected.end()));
+  { // erase(inplace_vector<T, N>, value)
+    inplace_vector vec{T(1), T(1337), T(1), T(12), T(0), T(-1)};
+    auto res = erase(vec, T(1));
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::size_type>::value, "");
+    assert(res == 2);
+    assert(equal_range(vec, cuda::std::array<T, 4>{T(1337), T(12), T(0), T(-1)}));
   }
 
-  {
-    cuda::std::initializer_list<T> expected_iter{T(1), T(42), T(12), T(0), T(-1)};
-    vec erase_iter{T(1), T(1337), T(42), T(12), T(0), T(-1)};
-    auto res_erase_iter = erase_iter.erase(erase_iter.begin() + 1);
-    static_assert(cuda::std::is_same<decltype(res_erase_iter), typename vec::iterator>::value, "");
-    assert(*res_erase_iter == T(42));
-    assert(cuda::std::equal(erase_iter.begin(), erase_iter.end(), expected_iter.begin(), expected_iter.end()));
-
-    cuda::std::initializer_list<T> expected_iter_iter{T(1), T(12), T(0), T(-1)};
-    vec erase_iter_iter{T(1), T(1337), T(42), T(12), T(0), T(-1)};
-    auto res_erase_iter_iter = erase_iter_iter.erase(erase_iter_iter.begin() + 1, erase_iter_iter.begin() + 3);
-    static_assert(cuda::std::is_same<decltype(res_erase_iter_iter), typename vec::iterator>::value, "");
-    assert(*res_erase_iter_iter == T(12));
-    assert(cuda::std::equal(
-      erase_iter_iter.begin(), erase_iter_iter.end(), expected_iter_iter.begin(), expected_iter_iter.end()));
+  { // erase_if(inplace_vector<T, N>, pred)
+    inplace_vector vec{T(1), T(1337), T(1), T(12), T(0), T(-1)};
+    auto res = erase_if(vec, is_one{});
+    static_assert(cuda::std::is_same<decltype(res), typename inplace_vector::size_type>::value, "");
+    assert(res == 2);
+    assert(equal_range(vec, cuda::std::array<T, 4>{T(1337), T(12), T(0), T(-1)}));
   }
+}
 
-  {
-    cuda::std::initializer_list<T> expected{T(1337), T(12), T(0), T(-1)};
-    vec erased{T(1), T(1337), T(1), T(12), T(0), T(-1)};
-    auto res_erase = erase(erased, T(1));
-    static_assert(cuda::std::is_same<decltype(res_erase), typename vec::size_type>::value, "");
-    assert(res_erase == 2);
-    assert(cuda::std::equal(erased.begin(), erased.end(), expected.begin(), expected.end()));
+template <class T>
+__host__ __device__ constexpr void test_shrink_to_fit()
+{
+  constexpr size_t max_capacity = 42ull;
+  using inplace_vector          = cuda::std::inplace_vector<T, max_capacity>;
 
-    vec erased_if{T(1), T(1337), T(1), T(12), T(0), T(-1)};
-    auto res_erase_if = erase_if(erased_if, is_one{});
-    static_assert(cuda::std::is_same<decltype(res_erase_if), typename vec::size_type>::value, "");
-    assert(res_erase_if == 2);
-    assert(cuda::std::equal(erased_if.begin(), erased_if.end(), expected.begin(), expected.end()));
+  { // inplace_vector<T, 0>::shrink_to_fit
+    cuda::std::inplace_vector<T, 0> vec{};
+    vec.shrink_to_fit();
+    assert(vec.empty());
   }
 
-  {
-    cuda::std::initializer_list<T> expected{T(1), T(1337), T(1), T(12), T(0), T(-1)};
-    vec shrink_to_fit{T(1), T(1337), T(1), T(12), T(0), T(-1)};
-    shrink_to_fit.shrink_to_fit();
-    assert(cuda::std::equal(shrink_to_fit.begin(), shrink_to_fit.end(), expected.begin(), expected.end()));
+  { // inplace_vector<T, N>::shrink_to_fit
+    inplace_vector vec{T(1), T(1337), T(1), T(12), T(0), T(-1)};
+    vec.shrink_to_fit();
+    assert(equal_range(vec, cuda::std::array<T, 6>{T(1), T(1337), T(1), T(12), T(0), T(-1)}));
   }
+}
 
-  {
-    cuda::std::initializer_list<T> expected{T(1), T(1337), T(1), T(12), T(0), T(-1)};
-    vec reserve{T(1), T(1337), T(1), T(12), T(0), T(-1)};
-    reserve.reserve(13);
-    assert(cuda::std::equal(reserve.begin(), reserve.end(), expected.begin(), expected.end()));
+template <class T>
+__host__ __device__ constexpr void test_reserve()
+{
+  constexpr size_t max_capacity = 42ull;
+  using inplace_vector          = cuda::std::inplace_vector<T, max_capacity>;
+
+  { // inplace_vector<T, 0>::reserve
+    cuda::std::inplace_vector<T, 0> vec{};
+    vec.reserve(0);
+    assert(vec.empty());
   }
+
+  { // inplace_vector<T, N>::reserve
+    inplace_vector vec{T(1), T(1337), T(1), T(12), T(0), T(-1)};
+    vec.reserve(13);
+    assert(equal_range(vec, cuda::std::array<T, 6>{T(1), T(1337), T(1), T(12), T(0), T(-1)}));
+  }
+}
+
+template <class T>
+__host__ __device__ constexpr void test()
+{
+  test_resize<T>();
+  test_clear<T>();
+  test_pop_back<T>();
+  test_erase<T>();
+  test_shrink_to_fit<T>();
+  test_reserve<T>();
 }
 
 __host__ __device__ constexpr bool test()
 {
   test<int>();
+  test<Trivial>();
 
   if (!cuda::std::__libcpp_is_constant_evaluated())
   {
@@ -145,8 +245,8 @@ __host__ __device__ constexpr bool test()
 void test_exceptions()
 { // resize and reserve throw std::bad_alloc
   {
-    using vec = cuda::std::inplace_vector<int, 42>;
-    vec too_small{};
+    using inplace_vector = cuda::std::inplace_vector<int, 42>;
+    inplace_vector too_small{};
     try
     {
       too_small.resize(1337);
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/swap.pass.cpp b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/swap.pass.cpp
index 2596c94f08..fdc7dd240b 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/swap.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/swap.pass.cpp
@@ -24,40 +24,41 @@
 template <class T>
 __host__ __device__ constexpr void test()
 {
-  {
-    using vec = cuda::std::inplace_vector<T, 42>;
-    cuda::std::initializer_list<T> expected_left{T(1), T(1337), T(42), T(12), T(0), T(-1)};
-    cuda::std::initializer_list<T> expected_right{T(0), T(42), T(1337), T(42), T(5), T(-42)};
+  { // inplace_vector<T, 0> can be swapped
+    using inplace_vector = cuda::std::inplace_vector<T, 0>;
+    inplace_vector empty{};
+    empty.swap(empty);
+    static_assert(noexcept(empty.swap(empty)), "");
+    swap(empty, empty);
+    static_assert(noexcept(swap(empty, empty)), "");
+  }
+
+  { // inplace_vector<T, N> can be swapped
+    using inplace_vector = cuda::std::inplace_vector<T, 42>;
+    const cuda::std::initializer_list<T> expected_left{T(1), T(1337), T(42), T(12), T(0), T(-1)};
+    const cuda::std::initializer_list<T> expected_right{T(0), T(42), T(1337), T(42), T(5), T(-42)};
 
-    vec left(expected_left);
-    vec right(expected_right);
+    inplace_vector left(expected_left);
+    inplace_vector right(expected_right);
 
     left.swap(right);
     constexpr bool nothrow_swap =
       cuda::std::is_nothrow_swappable<T>::value && cuda::std::is_nothrow_move_constructible<T>::value;
     static_assert(noexcept(left.swap(right)) == nothrow_swap, "");
-    assert(cuda::std::equal(left.begin(), left.end(), expected_right.begin(), expected_right.end()));
-    assert(cuda::std::equal(right.begin(), right.end(), expected_left.begin(), expected_left.end()));
+    assert(equal_range(left, expected_right));
+    assert(equal_range(right, expected_left));
 
     swap(left, right);
     static_assert(noexcept(swap(left, right)) == nothrow_swap, "");
-    assert(cuda::std::equal(left.begin(), left.end(), expected_left.begin(), expected_left.end()));
-    assert(cuda::std::equal(right.begin(), right.end(), expected_right.begin(), expected_right.end()));
-  }
-
-  {
-    using vec = cuda::std::inplace_vector<T, 0>;
-    vec empty{};
-    empty.swap(empty);
-    static_assert(noexcept(empty.swap(empty)), "");
-    swap(empty, empty);
-    static_assert(noexcept(swap(empty, empty)), "");
+    assert(equal_range(left, expected_left));
+    assert(equal_range(right, expected_right));
   }
 }
 
 __host__ __device__ constexpr bool test()
 {
   test<int>();
+  test<Trivial>();
 
   if (!cuda::std::__libcpp_is_constant_evaluated())
   {
diff --git a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/types.h b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/types.h
index 9843126591..834904f472 100644
--- a/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/types.h
+++ b/libcudacxx/test/libcudacxx/std/containers/sequences/inplace_vector/types.h
@@ -15,7 +15,12 @@
 
 struct Trivial
 {
-  int val_ = 0;
+  int val_;
+
+  Trivial() = default;
+  __host__ __device__ constexpr Trivial(const int val) noexcept
+      : val_(val)
+  {}
 
   __host__ __device__ friend constexpr bool operator==(const Trivial& lhs, const Trivial& rhs) noexcept
   {
@@ -239,4 +244,11 @@ static_assert(!cuda::std::ranges::common_range<sized_uncommon_range<int, 4>>);
 static_assert(cuda::std::ranges::sized_range<sized_uncommon_range<int, 4>>);
 #endif // TEST_STD_VER >= 2017 && !defined(TEST_COMPILER_MSVC_2017)
 
+// Helper function to compare two ranges
+template <class Range1, class Range2>
+__host__ __device__ constexpr bool equal_range(const Range1& range1, const Range2& range2)
+{
+  return cuda::std::equal(range1.begin(), range1.end(), range2.begin(), range2.end());
+}
+
 #endif // TEST_CONTAINER_SEQUENCES_INPLACE_VECTOR_TYPES_H