diff options
| author | Leitwolf11 | 2026-10-25 02:37:35 +0300 |
|---|---|---|
| committer | Leitwolf11 | 2026-10-25 02:37:35 +0300 |
| commit | 126dc333564cb72b5115d9a9242d66694694b6d0 (patch) | |
| tree | 0bce4462b2e190c39b3e1c5f697e3e4abd1a5e2a /src/Progmasoft/Catch3/Internal/StringRef.hpp | |
| parent | 13f81a480a93807c14dddb5abdb97355ced4d4c5 (diff) | |
| download | catch3-126dc333564cb72b5115d9a9242d66694694b6d0.tar.gz | |
Give Catch3 its own build names and headers
Catch2 compatibility means the API tests are written in: the macros, such
as TEST_CASE and REQUIRE, and the Catch:: namespace. It does not mean
Catch2's build names or header paths. find_package(Catch2) found Catch3,
and a project using both frameworks met two packages, two sets of targets,
two Catch.cmake modules and two catch2/ header trees with the same names.
Build names:
- CMake: project and package Catch3, targets Catch3::Catch3 and
Catch3::Catch3WithMain, libraries Catch3 and Catch3Main, options
CATCH3_*, lib/cmake/Catch3 with Catch3Config, and pkg-config catch3 and
catch3-with-main. The version is Catch3's, 0.3.0, compatible within a
minor version.
- The CMake scripts are Catch3.cmake (catch3_discover_tests),
Catch3AddTests.cmake and Catch3ShardTests.cmake
(catch3_add_sharded_tests); the helpers they define at ctest time have a
catch3_ prefix. ParseAndAddCatchTests.cmake, deprecated upstream, is gone.
- Bazel //:catch3 and //:catch3_main, Meson catch3 and catch3-with-main
(with override_dependency), Xmake catch3 and catch3_main, Premake Catch3
and Catch3WithMain. Visual Studio projects get GUIDs of their own.
- The Progmasoft::Catch3 target and package are gone: property testing
and snapshots are part of Catch3::Catch3. Their sources now build with
the library's warning flags, so property failures are built field by
field (no missing initializers) and the default property name is a
thread-local pointer to the name its scope owns (no global destructor).
Headers: the engine moved from src/catch2 to src/Progmasoft/Catch3 with
Progmasoft names, so <catch2/catch_test_macros.hpp> is
<Progmasoft/Catch3/TestMacros.hpp>, <catch2/matchers/catch_matchers_string.hpp>
is <Progmasoft/Catch3/Matchers/String.hpp>, and interface headers are named
after their interface, such as Interfaces/IConfig.hpp. Include guards
became #pragma once. The installed headers go to include/Progmasoft.
src/Progmasoft/Context.cpp is StrategyContext.cpp, so no two sources share
a file name.
tools/scripts/upstreamFiles.txt lists the files that come from Catch2.
The license check expects BSL-1.0 on them and Progmasoft's header on the
rest of src/Progmasoft; the convenience-header check, the amalgamation
script and the surrogate tests take the engine's headers from it. The
amalgamated files are regenerated. The header-guard workflow checks for
#pragma once instead of checkguard.
Documents, the README and the release notes describe the new names.
Diffstat (limited to 'src/Progmasoft/Catch3/Internal/StringRef.hpp')
| -rw-r--r-- | src/Progmasoft/Catch3/Internal/StringRef.hpp | 124 |
1 files changed, 124 insertions, 0 deletions
diff --git a/src/Progmasoft/Catch3/Internal/StringRef.hpp b/src/Progmasoft/Catch3/Internal/StringRef.hpp new file mode 100644 index 00000000..8f22159e --- /dev/null +++ b/src/Progmasoft/Catch3/Internal/StringRef.hpp @@ -0,0 +1,124 @@ + +// Copyright Catch2 Authors +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE.txt or copy at +// https://www.boost.org/LICENSE_1_0.txt) + +// SPDX-License-Identifier: BSL-1.0 +#pragma once + +#include <Progmasoft/Catch3/Internal/LifetimeBound.hpp> + +#include <cstddef> +#include <string> +#include <iosfwd> +#include <cassert> +#include <cstring> + +namespace Catch { + + /// A non-owning string class (similar to the forthcoming std::string_view) + /// Note that, because a StringRef may be a substring of another string, + /// it may not be null terminated. + class StringRef { + public: + using size_type = std::size_t; + using const_iterator = const char*; + + static constexpr size_type npos{ static_cast<size_type>( -1 ) }; + + private: + static constexpr char const* const s_empty = ""; + + char const* m_start = s_empty; + size_type m_size = 0; + + public: // construction + constexpr StringRef() noexcept = default; + + StringRef( char const* rawChars CATCH_ATTR_LIFETIMEBOUND ) noexcept; + + constexpr StringRef( char const* rawChars CATCH_ATTR_LIFETIMEBOUND, + size_type size ) noexcept + : m_start( rawChars ), + m_size( size ) + {} + + StringRef( + std::string const& stdString CATCH_ATTR_LIFETIMEBOUND ) noexcept + : m_start( stdString.c_str() ), + m_size( stdString.size() ) + {} + + explicit operator std::string() const { + return std::string(m_start, m_size); + } + + public: // operators + auto operator == ( StringRef other ) const noexcept -> bool { + return m_size == other.m_size + && (std::memcmp( m_start, other.m_start, m_size ) == 0); + } + auto operator != (StringRef other) const noexcept -> bool { + return !(*this == other); + } + + constexpr auto operator[] ( size_type index ) const noexcept -> char { + assert(index < m_size); + return m_start[index]; + } + + bool operator<(StringRef rhs) const noexcept; + + public: // named queries + constexpr auto empty() const noexcept -> bool { + return m_size == 0; + } + constexpr auto size() const noexcept -> size_type { + return m_size; + } + + // Returns a substring of [start, start + length). + // If start + length > size(), then the substring is [start, size()). + // If start > size(), then the substring is empty. + constexpr StringRef substr(size_type start, size_type length) const noexcept { + if (start < m_size) { + const auto shortened_size = m_size - start; + return StringRef(m_start + start, (shortened_size < length) ? shortened_size : length); + } else { + return StringRef(); + } + } + + // Returns the current start pointer. May not be null-terminated. + constexpr char const* data() const noexcept CATCH_ATTR_LIFETIMEBOUND { + return m_start; + } + + constexpr const_iterator begin() const { return m_start; } + constexpr const_iterator end() const { return m_start + m_size; } + + + friend std::string& operator += (std::string& lhs, StringRef rhs); + friend std::ostream& operator << (std::ostream& os, StringRef str); + friend std::string operator+(StringRef lhs, StringRef rhs); + + /** + * Provides a three-way comparison with rhs + * + * Returns negative number if lhs < rhs, 0 if lhs == rhs, and a positive + * number if lhs > rhs + */ + int compare( StringRef rhs ) const; + }; + + + constexpr auto operator ""_sr( char const* rawChars, std::size_t size ) noexcept -> StringRef { + return StringRef( rawChars, size ); + } +} // namespace Catch + +constexpr auto operator ""_catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef { + return Catch::StringRef( rawChars, size ); +} + |