[libcxx-commits] [libcxx] [libc++] Fix __split_buffer::reserve() (PR #105681)

[via libcxx-commits]

https://github.com/PaulXiCao created https://github.com/llvm/llvm-project/pull/105681

The function `__split_buffer::reserve()` did not reserve when instructed to.

Open questions about the tests:
- Do we implement unit tests for internal data structures at all?
- Is there another file I should include the tests into?
- Is there a more suitable folder to include the newly created test file into?

Note: This issue came up while working on #105379.

>From 2bd2bd7114c9ceb59135d83664220906d64b2052 Mon Sep 17 00:00:00 2001
From: Paul <paulxicao7 at gmail.com>
Date: Thu, 22 Aug 2024 16:30:58 +0200
Subject: [PATCH] fix reserve(); tests

---
 libcxx/include/__split_buffer                 |  2 +-
 .../libcxx/utilities/split_buffer.pass.cpp    | 69 +++++++++++++++++++
 2 files changed, 70 insertions(+), 1 deletion(-)
 create mode 100644 libcxx/test/libcxx/utilities/split_buffer.pass.cpp

diff --git a/libcxx/include/__split_buffer b/libcxx/include/__split_buffer
index bab724d1b8963b..381e3d2bc7b7c8 100644
--- a/libcxx/include/__split_buffer
+++ b/libcxx/include/__split_buffer
@@ -430,7 +430,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::swap(__split
 
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::reserve(size_type __n) {
-  if (__n < capacity()) {
+  if (__n > capacity()) {
     __split_buffer<value_type, __alloc_rr&> __t(__n, 0, __alloc());
     __t.__construct_at_end(move_iterator<pointer>(__begin_), move_iterator<pointer>(__end_));
     std::swap(__first_, __t.__first_);
diff --git a/libcxx/test/libcxx/utilities/split_buffer.pass.cpp b/libcxx/test/libcxx/utilities/split_buffer.pass.cpp
new file mode 100644
index 00000000000000..6ce361508fd2d2
--- /dev/null
+++ b/libcxx/test/libcxx/utilities/split_buffer.pass.cpp
@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__split_buffer>
+#include <__config>
+#include <cassert>
+#include <memory>
+#include <type_traits>
+#include <string>
+
+#include "test_macros.h"
+
+struct simple_test_type {
+  int value;
+};
+
+struct complex_test_type {
+  std::string value;
+  complex_test_type(const std::string& v) : value(v) {}
+};
+
+template <class TEST_TYPE>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 int capacity_after_initialization() {
+  std::__split_buffer<TEST_TYPE> sb;
+  return sb.capacity();
+}
+
+template <class TEST_TYPE>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 int capacity_after_reserve(const std::size_t n) {
+  std::__split_buffer<TEST_TYPE> sb;
+  sb.reserve(n);
+  return sb.capacity();
+}
+
+int main() {
+  { // check test_types' features
+#if _LIBCPP_STD_VER >= 17
+    static_assert(std::is_trivially_copyable_v<simple_test_type>);
+    static_assert(not std::is_trivially_copyable_v<complex_test_type>);
+#endif
+  }
+
+  { // test simple_test_type at run-time
+    assert(0 == capacity_after_initialization<simple_test_type>());
+    assert(42 == capacity_after_reserve<simple_test_type>(42));
+  }
+
+  { // test complex_test_type at run-time
+    assert(0 == capacity_after_initialization<complex_test_type>());
+    assert(42 == capacity_after_reserve<complex_test_type>(42));
+  }
+
+#if _LIBCPP_STD_VER >= 20
+  { // test simple_test_type at compile-time
+    static_assert(0 == capacity_after_initialization<simple_test_type>());
+    static_assert(42 == capacity_after_reserve<simple_test_type>(42));
+  }
+
+  { // test complex_test_type at compile-time
+    static_assert(0 == capacity_after_initialization<complex_test_type>());
+    static_assert(42 == capacity_after_reserve<complex_test_type>(42));
+  }
+#endif
+}