add aliases test

include/magic_enum.hpp

@@ -246,12 +246,12 @@ constexpr string_view pretty_name(string_view name) noexcept {
     }
   }
 
-  if (name.size() > 0 && ((name.front() >= 'a' && name.front() <= 'z') ||
-                          (name.front() >= 'A' && name.front() <= 'Z') ||
+  if (name.size() > 0 && ((name[0] >= 'a' && name[0] <= 'z') ||
+                          (name[0] >= 'A' && name[0] <= 'Z') ||
 #if defined(MAGIC_ENUM_ENABLE_NONASCII)
-                          (name.front() & 0x80) ||
+                          (name[0]) & 0x80) ||
 #endif
-                          (name.front() == '_'))) {
+                          (name[0] == '_'))) {
     return name;
   }
 
@@ -293,7 +293,7 @@ constexpr std::size_t find(string_view str, char c) noexcept {
 
     return string_view::npos;
   } else {
-    return str.find_first_of(c);
+    return str.find(c);
   }
 }
 

test/CMakeLists.txt

@@ -1,7 +1,5 @@
 include(CheckCXXCompilerFlag)
 
-set(SOURCES test.cpp)
-
 if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
     set(OPTIONS /W4 /WX)
     check_cxx_compiler_flag(/permissive HAS_PERMISSIVE_FLAG)
@@ -10,12 +8,14 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
     endif()
 
     check_cxx_compiler_flag(/std:c++20 HAS_CPP20_FLAG)
+    check_cxx_compiler_flag(/std:c++23 HAS_CPP23_FLAG)
     check_cxx_compiler_flag(/std:c++latest HAS_CPPLATEST_FLAG)
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
     set(CMAKE_VERBOSE_MAKEFILE ON)
     set(OPTIONS -Wall -Wextra -pedantic-errors -Werror)
 
     check_cxx_compiler_flag(-std=c++20 HAS_CPP20_FLAG)
+    check_cxx_compiler_flag(-std=c++23 HAS_CPP23_FLAG)
 endif()
 
 if(MAGIC_ENUM_OPT_ENABLE_NONASCII)
@@ -44,13 +44,22 @@ endfunction()
 
 make_test(test.cpp test-cpp17 c++17)
 make_test(test_flags.cpp test_flags-cpp17 c++17)
+make_test(test_aliases.cpp test_aliases-cpp17 c++17)
 
 if(HAS_CPP20_FLAG)
     make_test(test.cpp test-cpp20 c++20)
     make_test(test_flags.cpp test_flags-cpp20 c++20)
+    make_test(test_aliases.cpp test_aliases-cpp20 c++20)
+endif()
+
+if(HAS_CPP23_FLAG)
+    make_test(test.cpp test-cpp23 c++23)
+    make_test(test_flags.cpp test_flags-cpp23 c++23)
+    make_test(test_aliases.cpp test_aliases-cpp23 c++23)
 endif()
 
 if(HAS_CPPLATEST_FLAG)
     make_test(test.cpp test-cpplatest c++latest)
     make_test(test_flags.cpp test_flags-cpplatest c++latest)
+    make_test(test_aliases.cpp test_aliases-cpplatest c++latest)
 endif()

test/test_aliases.cpp

@@ -0,0 +1,130 @@
+// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2019 - 2022 Daniil Goncharov <neargye@gmail.com>.
+//
+// Permission is hereby  granted, free of charge, to any  person obtaining a copy
+// of this software and associated  documentation files (the "Software"), to deal
+// in the Software  without restriction, including without  limitation the rights
+// to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+// copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+// IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+// FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+// AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+// LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <optional>
+#include <string>
+#include <string_view>
+
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
+
+template <typename T>
+struct MyOpt {
+  constexpr MyOpt() : mHasValue{false}, val{} {} // required
+  constexpr MyOpt(const T& v) : mHasValue{true}, val{v} {} // required
+  constexpr const T& operator*() const { return val; } // required
+  constexpr explicit operator bool() const  { return mHasValue; } // required
+
+  constexpr bool has_value() const { return mHasValue; }
+  constexpr const T& value() const { return val; }
+
+ private:
+  bool mHasValue;
+  T val;
+};
+
+struct MyString {
+  MyString() : str{} {} // required
+  MyString(const char* s, std::size_t l) : str{s, l} {} // required
+  bool empty() const { return str.empty(); } // required
+  void append(std::size_t count, char c) { str.append(count, c); } // required
+  void append(const char* s, std::size_t size) { str.append(s, size); } // required
+
+  std::size_t size() const { return str.size(); }
+  int compare(const char* s) const { return str.compare(s); }
+
+ private:
+  std::string str;
+};
+
+struct MyStringView {
+  using value_type = char; // required
+  static constexpr auto npos = std::string_view::npos; // required
+
+  constexpr MyStringView() : str{} {} // required
+  constexpr MyStringView(const char* cstr, std::size_t size) : str{cstr, size} {} // required
+  constexpr bool empty() const { return str.empty(); } // required
+  constexpr std::size_t size() const { return str.size(); } // required
+  constexpr const char* data() const { return str.data(); } // required
+  constexpr const char& operator[](std::size_t i) const { return str[i]; } // required
+  constexpr auto begin() const { return str.begin(); } // required
+  constexpr auto end() const { return str.end(); } // required
+  constexpr std::size_t find(char c) const { return str.find(c); } // required
+  constexpr MyStringView substr(std::size_t p, std::size_t n) { return str.substr(p, n); } // required
+  constexpr void remove_prefix(std::size_t n) { str.remove_prefix(n); } // required
+  friend constexpr bool operator==(MyStringView lhs, MyStringView rhs); // required
+
+  constexpr MyStringView(const char* cstr) : str{ cstr } {}
+  constexpr int compare(const char* s) const { return str.compare(s); }
+
+ private:
+  std::string_view str;
+
+  constexpr MyStringView(std::string_view s) : str{s} {}
+};
+
+constexpr bool operator==(MyStringView lhs, MyStringView rhs) {
+  return lhs.str == rhs.str;
+}
+
+#define MAGIC_ENUM_USING_ALIAS_OPTIONAL template<typename T> using optional = MyOpt<T>;
+#define MAGIC_ENUM_USING_ALIAS_STRING using string = MyString;
+#define MAGIC_ENUM_USING_ALIAS_STRING_VIEW using string_view = MyStringView;
+
+#include <magic_enum.hpp>
+using namespace magic_enum;
+using namespace magic_enum::bitwise_operators;
+
+enum class Color { RED = 1, GREEN = 2, BLUE = 4 };
+
+TEST_CASE("optional") {
+  constexpr auto cr = enum_cast<Color>("RED");
+  REQUIRE(cr.has_value());
+  REQUIRE(cr.value() == Color::RED);
+
+  constexpr auto cn = enum_cast<Color>("NONE");
+  REQUIRE_FALSE(cn.has_value());
+}
+
+TEST_CASE("string") {
+  auto cr = enum_flags_name(Color::RED);
+  REQUIRE_FALSE(cr.empty());
+  REQUIRE(cr.compare("RED") == 0);
+
+  auto crg = enum_flags_name(Color::RED | Color::GREEN);
+  REQUIRE_FALSE(crg.empty());
+  REQUIRE(crg.compare("RED|GREEN") == 0);
+
+  auto cn = enum_flags_name(Color{0});
+  REQUIRE(cn.empty());
+  REQUIRE(cn.size() == 0);
+}
+
+TEST_CASE("string_view") {
+  auto cr = enum_name(Color::RED);
+  REQUIRE_FALSE(cr.empty());
+  REQUIRE(cr.compare("RED") == 0);
+
+  auto cn = enum_name(Color{0});
+  REQUIRE(cn.empty());
+  REQUIRE(cn.size() == 0);
+}