[libcxx-commits] [libcxx] ae2ae84 - [libc++][test] Refactor SmallBasicString uses in range.lazy.split tests
Joe Loser via libcxx-commits
libcxx-commits at lists.llvm.org
Sat Jun 11 13:01:31 PDT 2022
Author: Joe Loser
Date: 2022-06-11T13:10:02-06:00
New Revision: ae2ae84ffed3662fda4c516f6e9d62a7f780b169
URL: https://github.com/llvm/llvm-project/commit/ae2ae84ffed3662fda4c516f6e9d62a7f780b169
DIFF: https://github.com/llvm/llvm-project/commit/ae2ae84ffed3662fda4c516f6e9d62a7f780b169.diff
LOG: [libc++][test] Refactor SmallBasicString uses in range.lazy.split tests
The tests for `std::ranges::lazy_split_view` heavily use a wrapper class around
`std::string` because `std::string` was not `constexpr` until recently. Where
possible, remove the wrapper class and extra functionality no longer needed.
Remove `libcxx/test/std/ranges/range.adaptors/range.lazy.split/small_string.h`
and inline its one use remaining in
`libcxx/test/std/ranges/range.adaptors/range.lazy.split/general.pass.cpp`.
Differential Revision: https://reviews.llvm.org/D126663
Added:
Modified:
libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.copy_move.pass.cpp
libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.range.pass.cpp
libcxx/test/std/ranges/range.adaptors/range.lazy.split/general.pass.cpp
libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/deref.pass.cpp
libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/increment.pass.cpp
libcxx/test/std/ranges/range.adaptors/range.lazy.split/types.h
Removed:
libcxx/test/std/ranges/range.adaptors/range.lazy.split/small_string.h
################################################################################
diff --git a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.copy_move.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.copy_move.pass.cpp
index 97e172c08281b..8cf19ef458aee 100644
--- a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.copy_move.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.copy_move.pass.cpp
@@ -16,13 +16,8 @@
#include <cassert>
#include <string_view>
#include <utility>
-#include "small_string.h"
#include "types.h"
-constexpr bool operator==(const InputView& lhs, const InputView& rhs) {
- return SmallString(lhs) == SmallString(rhs);
-}
-
constexpr bool test() {
// Can copy `lazy_split_view`.
{
diff --git a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.range.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.range.pass.cpp
index bde1cb650f189..fa083bf445767 100644
--- a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.range.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.range.pass.cpp
@@ -17,10 +17,10 @@
#include <ranges>
#include <cassert>
+#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
-#include "small_string.h"
#include "types.h"
struct ElementWithCounting {
@@ -72,24 +72,15 @@ struct RangeWithCounting {
static_assert( std::ranges::forward_range<RangeWithCounting>);
static_assert(!std::ranges::view<RangeWithCounting>);
-struct StrRange {
- SmallString buffer_;
- constexpr explicit StrRange() = default;
- constexpr StrRange(const char* ptr) : buffer_(ptr) {}
- constexpr const char* begin() const { return buffer_.begin(); }
- constexpr const char* end() const { return buffer_.end(); }
- constexpr bool operator==(const StrRange& rhs) const { return buffer_ == rhs.buffer_; }
-};
-static_assert( std::ranges::random_access_range<StrRange>);
-static_assert(!std::ranges::view<StrRange>);
-static_assert( std::is_copy_constructible_v<StrRange>);
-
struct StrView : std::ranges::view_base {
- SmallString buffer_;
+ std::string_view buffer_;
constexpr explicit StrView() = default;
constexpr StrView(const char* ptr) : buffer_(ptr) {}
+ // Intentionally don't forward to range constructor for std::string_view since
+ // this test needs to work on C++20 as well and the range constructor is only for
+ // C++23 and later.
template <std::ranges::range R>
- constexpr StrView(R&& r) : buffer_(std::forward<R>(r)) {}
+ constexpr StrView(R&& r) : buffer_(r.begin(), r.end()) {}
constexpr const char* begin() const { return buffer_.begin(); }
constexpr const char* end() const { return buffer_.end(); }
constexpr bool operator==(const StrView& rhs) const { return buffer_ == rhs.buffer_; }
@@ -102,9 +93,9 @@ constexpr bool test() {
{
using V = std::ranges::lazy_split_view<StrView, StrView>;
- // Calling the constructor with `(StrRange, range_value_t)`.
+ // Calling the constructor with `(std::string, range_value_t)`.
{
- StrRange input;
+ std::string input;
V v(input, ' ');
assert(v.base() == input);
}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/general.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/general.pass.cpp
index 52793ab1304fd..440fca85638a6 100644
--- a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/general.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/general.pass.cpp
@@ -25,9 +25,33 @@
#include <string_view>
#include <utility>
#include <vector>
-#include "small_string.h"
#include "types.h"
+// A constexpr-friendly lightweight string, primarily useful for comparisons.
+// Unlike `std::string_view`, it copies the given string into an
+// internal buffer and can work with non-contiguous inputs.
+template <class Char>
+class BasicSmallString {
+ std::basic_string<Char> buffer_{};
+
+public:
+ constexpr BasicSmallString(std::basic_string_view<Char> v) : buffer_(v) {}
+
+ template <class I, class S>
+ constexpr BasicSmallString(I b, const S& e) {
+ for (; b != e; ++b) {
+ buffer_ += *b;
+ }
+ }
+
+ template <std::ranges::range R>
+ constexpr BasicSmallString(R&& from) : BasicSmallString(from.begin(), from.end()) {}
+
+ friend constexpr bool operator==(const BasicSmallString& lhs, const BasicSmallString& rhs) {
+ return lhs.buffer_ == rhs.buffer_;
+ }
+};
+
template <std::ranges::view View, std::ranges::range Expected>
constexpr bool is_equal(View& view, const Expected& expected) {
using Char = std::ranges::range_value_t<std::ranges::range_value_t<View>>;
@@ -55,7 +79,7 @@ constexpr bool test_with_piping(T&& input, Separator&& separator, std::array<U,
for (auto e : input | std::ranges::views::lazy_split(separator)) {
if (expected_it == expected.end())
return false;
- if (SmallString(e) != *expected_it)
+ if (!std::ranges::equal(e, *expected_it))
return false;
++expected_it;
diff --git a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/deref.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/deref.pass.cpp
index 794505eb61e17..375607c81cfa4 100644
--- a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/deref.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/deref.pass.cpp
@@ -13,14 +13,16 @@
#include <ranges>
+#include <algorithm>
#include <cassert>
+#include <string>
#include <string_view>
#include <type_traits>
-#include "../small_string.h"
#include "../types.h"
template <class View, class Separator>
constexpr void test_one(Separator sep) {
+ using namespace std::string_literals;
using namespace std::string_view_literals;
View v("abc def ghi"sv, sep);
@@ -29,16 +31,16 @@ constexpr void test_one(Separator sep) {
{
auto i = v.begin();
static_assert(!std::is_reference_v<decltype(*i)>);
- assert(SmallString(*i) == "abc"_str);
- assert(SmallString(*(++i)) == "def"_str);
- assert(SmallString(*(++i)) == "ghi"_str);
+ assert(std::ranges::equal(*i, "abc"s));
+ assert(std::ranges::equal(*(++i), "def"s));
+ assert(std::ranges::equal(*(++i), "ghi"s));
}
// Const iterator.
{
const auto ci = v.begin();
static_assert(!std::is_reference_v<decltype(*ci)>);
- assert(SmallString(*ci) == "abc"_str);
+ assert(std::ranges::equal(*ci, "abc"s));
}
}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/increment.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/increment.pass.cpp
index 1e234e4efbd32..e2c023eea88fb 100644
--- a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/increment.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/increment.pass.cpp
@@ -17,11 +17,12 @@
#include <ranges>
#include <algorithm>
-#include <string_view>
-#include "../small_string.h"
+#include <cassert>
+#include <string>
#include "../types.h"
constexpr bool test() {
+ using namespace std::string_literals;
// Can call `outer-iterator::operator++`; `View` is a forward range.
{
SplitViewForward v("abc def ghi", " ");
@@ -29,23 +30,23 @@ constexpr bool test() {
// ++i
{
auto i = v.begin();
- assert(*i == "abc"_str);
+ assert(std::ranges::equal(*i, "abc"s));
decltype(auto) i2 = ++i;
static_assert(std::is_lvalue_reference_v<decltype(i2)>);
assert(&i2 == &i);
- assert(*i2 == "def"_str);
+ assert(std::ranges::equal(*i2, "def"s));
}
// i++
{
auto i = v.begin();
- assert(*i == "abc"_str);
+ assert(std::ranges::equal(*i, "abc"s));
decltype(auto) i2 = i++;
static_assert(!std::is_reference_v<decltype(i2)>);
- assert(*i2 == "abc"_str);
- assert(*i == "def"_str);
+ assert(std::ranges::equal(*i2, "abc"s));
+ assert(std::ranges::equal(*i, "def"s));
}
}
@@ -56,22 +57,22 @@ constexpr bool test() {
// ++i
{
auto i = v.begin();
- assert(*i == "abc"_str);
+ assert(std::ranges::equal(*i, "abc"s));
decltype(auto) i2 = ++i;
static_assert(std::is_lvalue_reference_v<decltype(i2)>);
assert(&i2 == &i);
- assert(*i2 == "def"_str);
+ assert(std::ranges::equal(*i2, "def"s));
}
// i++
{
auto i = v.begin();
- assert(*i == "abc"_str);
+ assert(std::ranges::equal(*i, "abc"s));
static_assert(std::is_void_v<decltype(i++)>);
i++;
- assert(*i == "def"_str);
+ assert(std::ranges::equal(*i, "def"s));
}
}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/small_string.h b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/small_string.h
deleted file mode 100644
index 362d0809f29a6..0000000000000
--- a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/small_string.h
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_LAZY_SPLIT_SMALL_STRING_H
-#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_LAZY_SPLIT_SMALL_STRING_H
-
-#include <algorithm>
-#include <cassert>
-#include <ranges>
-#include <string_view>
-
-// A constexpr-friendly lightweight string, primarily useful for comparisons.
-// Unlike `std::string`, all functions are `constexpr`. Unlike `std::string_view`, it copies the given string into an
-// internal buffer and can work with non-contiguous inputs.
-//
-// TODO(var-const): remove once https://reviews.llvm.org/D110598 lands and `std::string` can be used instead of this
-// class.
-template <class Char>
-class BasicSmallString {
- constexpr static int N = 32;
- Char buffer_[N] = {};
- size_t size_ = 0;
-
-public:
- // Main constructors.
-
- constexpr BasicSmallString() = default;
-
- constexpr BasicSmallString(std::basic_string_view<Char> v) : size_(v.size()) {
- assert(size_ < N);
- if (size_ == 0) return;
-
- std::copy(v.begin(), v.end(), buffer_);
- }
-
- template <class I, class S>
- constexpr BasicSmallString(I b, const S& e) {
- for (; b != e; ++b) {
- buffer_[size_++] = *b;
- assert(size_ < N);
- }
- }
-
- // Delegating constructors.
-
- constexpr BasicSmallString(const Char* ptr, size_t size) : BasicSmallString(std::basic_string_view<Char>(ptr, size)) {
- }
-
- template <std::ranges::range R>
- constexpr BasicSmallString(R&& from) : BasicSmallString(from.begin(), from.end()) {
- }
-
- // Iterators.
-
- constexpr Char* begin() { return buffer_; }
- constexpr Char* end() { return buffer_ + size_; }
- constexpr const Char* begin() const { return buffer_; }
- constexpr const Char* end() const { return buffer_ + size_; }
-
- friend constexpr bool operator==(const BasicSmallString& lhs, const BasicSmallString& rhs) {
- return lhs.size_ == rhs.size_ && std::equal(lhs.buffer_, lhs.buffer_ + lhs.size_, rhs.buffer_);
- }
- friend constexpr bool operator==(const BasicSmallString& lhs, std::string_view rhs) {
- return lhs == BasicSmallString(rhs);
- }
-};
-
-using SmallString = BasicSmallString<char>;
-
-inline constexpr SmallString operator "" _str(const char* ptr, size_t size) {
- return SmallString(ptr, size);
-}
-
-#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_LAZY_SPLIT_SMALL_STRING_H
diff --git a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/types.h b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/types.h
index 3cb4a0d914845..a606e915f04df 100644
--- a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/types.h
@@ -11,9 +11,9 @@
#include <concepts>
#include <ranges>
+#include <string>
#include <string_view>
#include <type_traits>
-#include "small_string.h"
#include "test_macros.h"
#include "test_iterators.h"
@@ -55,18 +55,21 @@ static_assert( std::is_move_constructible_v<ForwardView>);
// Iterator types
diff er based on constness of this class.
struct ForwardDiffView : std::ranges::view_base {
- SmallString buffer_;
+ std::string buffer_;
constexpr explicit ForwardDiffView() = default;
constexpr ForwardDiffView(const char* ptr) : ForwardDiffView(std::string_view(ptr)) {}
- constexpr ForwardDiffView(std::string_view v) : buffer_(v) {}
+ constexpr ForwardDiffView(std::string_view v) {
+ // Workaround https://github.com/llvm/llvm-project/issues/55867
+ buffer_ = v;
+ }
constexpr ForwardDiffView(ForwardDiffView&&) = default;
constexpr ForwardDiffView& operator=(ForwardDiffView&&) = default;
constexpr ForwardDiffView(const ForwardDiffView&) = default;
constexpr ForwardDiffView& operator=(const ForwardDiffView&) = default;
- constexpr forward_iterator<char*> begin() { return forward_iterator<char*>(buffer_.begin()); }
- constexpr forward_iterator<char*> end() { return forward_iterator<char*>(buffer_.end()); }
- constexpr forward_iterator<const char*> begin() const { return forward_iterator<const char*>(buffer_.begin()); }
- constexpr forward_iterator<const char*> end() const { return forward_iterator<const char*>(buffer_.end()); }
+ constexpr forward_iterator<char*> begin() { return forward_iterator<char*>(buffer_.begin().base()); }
+ constexpr forward_iterator<char*> end() { return forward_iterator<char*>(buffer_.end().base()); }
+ constexpr forward_iterator<const char*> begin() const { return forward_iterator<const char*>(buffer_.begin().base()); }
+ constexpr forward_iterator<const char*> end() const { return forward_iterator<const char*>(buffer_.end().base()); }
};
static_assert( std::ranges::forward_range<ForwardView>);
static_assert( std::ranges::forward_range<const ForwardView>);
@@ -135,21 +138,27 @@ static_assert( std::ranges::view<ForwardOnlyIfNonConstView>);
// InputView
struct InputView : std::ranges::view_base {
- SmallString buffer_;
+ std::string buffer_;
constexpr InputView() = default;
constexpr InputView(const char* s) : InputView(std::string_view(s)) {}
- constexpr InputView(std::string_view v) : buffer_(v) {}
+ constexpr InputView(std::string_view v) {
+ // Workaround https://github.com/llvm/llvm-project/issues/55867
+ buffer_ = v;
+ }
- constexpr cpp20_input_iterator<char*> begin() { return cpp20_input_iterator<char*>(buffer_.begin()); }
+ constexpr cpp20_input_iterator<char*> begin() { return cpp20_input_iterator<char*>(buffer_.begin().base()); }
constexpr sentinel_wrapper<cpp20_input_iterator<char*>> end() {
- return sentinel_wrapper(cpp20_input_iterator<char*>(buffer_.end()));
+ return sentinel_wrapper(cpp20_input_iterator<char*>(buffer_.end().base()));
}
constexpr cpp20_input_iterator<const char*> begin() const {
- return cpp20_input_iterator<const char*>(buffer_.begin());
+ return cpp20_input_iterator<const char*>(buffer_.begin().base());
}
constexpr sentinel_wrapper<cpp20_input_iterator<const char*>> end() const {
- return sentinel_wrapper(cpp20_input_iterator<const char*>(buffer_.end()));
+ return sentinel_wrapper(cpp20_input_iterator<const char*>(buffer_.end().base()));
+ }
+ friend constexpr bool operator==(const InputView& lhs, const InputView& rhs) {
+ return lhs.buffer_ == rhs.buffer_;
}
};
More information about the libcxx-commits
mailing list