mirror of
https://github.com/Neargye/magic_enum.git
synced 2026-01-10 23:44:29 +00:00
304 lines
13 KiB
C++
304 lines
13 KiB
C++
// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
|
|
// SPDX-License-Identifier: MIT
|
|
// Copyright (c) 2019 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.
|
|
|
|
#define CATCH_CONFIG_MAIN
|
|
#include <catch.hpp>
|
|
|
|
#define MAGIC_ENUM_RANGE_MIN -120
|
|
#define MAGIC_ENUM_RANGE_MAX 120
|
|
#include <magic_enum.hpp>
|
|
|
|
#include <array>
|
|
#include <string_view>
|
|
#include <sstream>
|
|
|
|
enum class Color { RED = -12, GREEN = 7, BLUE = 15 };
|
|
|
|
enum class Numbers : char { one = 10, two = 20, three = 30, many = 127 };
|
|
|
|
enum Directions { Up = 85, Down = -42, Right = 120, Left = -120 };
|
|
|
|
enum number : unsigned long { zero = 0, one = 100, two = 200, three = 300, four = 400 };
|
|
|
|
namespace magic_enum {
|
|
template <>
|
|
struct enum_range<number> {
|
|
static constexpr int min = 100;
|
|
static constexpr int max = 300;
|
|
};
|
|
}
|
|
|
|
TEST_CASE("enum_cast") {
|
|
SECTION("string") {
|
|
#if defined(_MSC_VER) && _MSC_VER < 1920
|
|
# define constexpr // Visual Studio 2017 have bug with string_view constexpr compare.
|
|
#endif
|
|
|
|
constexpr auto cr = magic_enum::enum_cast<Color>("RED");
|
|
REQUIRE(cr.value() == Color::RED);
|
|
REQUIRE(magic_enum::enum_cast<Color>("GREEN").value() == Color::GREEN);
|
|
REQUIRE(magic_enum::enum_cast<Color>("BLUE").value() == Color::BLUE);
|
|
REQUIRE_FALSE(magic_enum::enum_cast<Color>("None").has_value());
|
|
|
|
constexpr auto no = magic_enum::enum_cast<Numbers>("one");
|
|
REQUIRE(no.value() == Numbers::one);
|
|
REQUIRE(magic_enum::enum_cast<Numbers>("two").value() == Numbers::two);
|
|
REQUIRE(magic_enum::enum_cast<Numbers>("three").value() == Numbers::three);
|
|
REQUIRE_FALSE(magic_enum::enum_cast<Numbers>("many").has_value());
|
|
REQUIRE_FALSE(magic_enum::enum_cast<Numbers>("None").has_value());
|
|
|
|
constexpr auto dr = magic_enum::enum_cast<Directions>("Right");
|
|
REQUIRE(magic_enum::enum_cast<Directions>("Up").value() == Directions::Up);
|
|
REQUIRE(magic_enum::enum_cast<Directions>("Down").value() == Directions::Down);
|
|
REQUIRE(dr.value() == Directions::Right);
|
|
REQUIRE(magic_enum::enum_cast<Directions>("Left").value() == Directions::Left);
|
|
REQUIRE_FALSE(magic_enum::enum_cast<Directions>("None").has_value());
|
|
|
|
constexpr auto nt = magic_enum::enum_cast<number>("three");
|
|
REQUIRE(magic_enum::enum_cast<number>("one").value() == number::one);
|
|
REQUIRE(magic_enum::enum_cast<number>("two").value() == number::two);
|
|
REQUIRE(nt.value() == number::three);
|
|
REQUIRE_FALSE(magic_enum::enum_cast<number>("zero").has_value());
|
|
REQUIRE_FALSE(magic_enum::enum_cast<number>("four").has_value());
|
|
REQUIRE_FALSE(magic_enum::enum_cast<number>("None").has_value());
|
|
|
|
#undef constexpr
|
|
}
|
|
|
|
SECTION("integer") {
|
|
constexpr auto cr = magic_enum::enum_cast<Color>(-12);
|
|
REQUIRE(cr.value() == Color::RED);
|
|
REQUIRE(magic_enum::enum_cast<Color>(7).value() == Color::GREEN);
|
|
REQUIRE(magic_enum::enum_cast<Color>(15).value() == Color::BLUE);
|
|
REQUIRE_FALSE(magic_enum::enum_cast<Color>(0).has_value());
|
|
|
|
constexpr auto no = magic_enum::enum_cast<Numbers>(10);
|
|
REQUIRE(no.value() == Numbers::one);
|
|
REQUIRE(magic_enum::enum_cast<Numbers>(20).value() == Numbers::two);
|
|
REQUIRE(magic_enum::enum_cast<Numbers>(30).value() == Numbers::three);
|
|
REQUIRE_FALSE(magic_enum::enum_cast<Numbers>(127).has_value());
|
|
REQUIRE_FALSE(magic_enum::enum_cast<Numbers>(0).has_value());
|
|
|
|
constexpr auto dr = magic_enum::enum_cast<Directions>(120);
|
|
REQUIRE(magic_enum::enum_cast<Directions>(85).value() == Directions::Up);
|
|
REQUIRE(magic_enum::enum_cast<Directions>(-42).value() == Directions::Down);
|
|
REQUIRE(dr.value() == Directions::Right);
|
|
REQUIRE(magic_enum::enum_cast<Directions>(-120).value() == Directions::Left);
|
|
REQUIRE_FALSE(magic_enum::enum_cast<Directions>(0).has_value());
|
|
|
|
constexpr auto nt = magic_enum::enum_cast<number>(300);
|
|
REQUIRE(magic_enum::enum_cast<number>(100).value() == number::one);
|
|
REQUIRE(magic_enum::enum_cast<number>(200).value() == number::two);
|
|
REQUIRE(nt.value() == number::three);
|
|
REQUIRE_FALSE(magic_enum::enum_cast<number>(400).has_value());
|
|
REQUIRE_FALSE(magic_enum::enum_cast<number>(0).has_value());
|
|
}
|
|
}
|
|
|
|
TEST_CASE("enum_integer") {
|
|
constexpr auto cr = magic_enum::enum_integer(Color::RED);
|
|
REQUIRE(cr == -12);
|
|
REQUIRE(magic_enum::enum_integer(Color::GREEN) == 7);
|
|
REQUIRE(magic_enum::enum_integer(Color::BLUE) == 15);
|
|
REQUIRE(magic_enum::enum_integer(static_cast<Color>(0)) == 0);
|
|
|
|
constexpr auto no = magic_enum::enum_integer(Numbers::one);
|
|
REQUIRE(no == 10);
|
|
REQUIRE(magic_enum::enum_integer(Numbers::two) == 20);
|
|
REQUIRE(magic_enum::enum_integer(Numbers::three) == 30);
|
|
REQUIRE(magic_enum::enum_integer(Numbers::many) == 127);
|
|
REQUIRE(magic_enum::enum_integer(static_cast<Numbers>(0)) == 0);
|
|
|
|
constexpr auto dr = magic_enum::enum_integer(Directions::Right);
|
|
REQUIRE(magic_enum::enum_integer(Directions::Left) == -120);
|
|
REQUIRE(magic_enum::enum_integer(Directions::Down) == -42);
|
|
REQUIRE(magic_enum::enum_integer(Directions::Up) == 85);
|
|
REQUIRE(dr == 120);
|
|
REQUIRE(magic_enum::enum_integer(static_cast<Directions>(0)) == 0);
|
|
|
|
constexpr auto nt = magic_enum::enum_integer(number::three);
|
|
REQUIRE(magic_enum::enum_integer(number::zero) == 0);
|
|
REQUIRE(magic_enum::enum_integer(number::one) == 100);
|
|
REQUIRE(magic_enum::enum_integer(number::two) == 200);
|
|
REQUIRE(nt == 300);
|
|
REQUIRE(magic_enum::enum_integer(number::four) == 400);
|
|
REQUIRE(magic_enum::enum_integer(static_cast<number>(0)) == 0);
|
|
}
|
|
|
|
TEST_CASE("enum_value") {
|
|
constexpr auto cr = magic_enum::enum_value<Color>(0);
|
|
REQUIRE(cr == Color::RED);
|
|
REQUIRE(magic_enum::enum_value<Color>(1) == Color::GREEN);
|
|
REQUIRE(magic_enum::enum_value<Color>(2) == Color::BLUE);
|
|
|
|
constexpr auto no = magic_enum::enum_value<Numbers>(0);
|
|
REQUIRE(no == Numbers::one);
|
|
REQUIRE(magic_enum::enum_value<Numbers>(1) == Numbers::two);
|
|
REQUIRE(magic_enum::enum_value<Numbers>(2) == Numbers::three);
|
|
|
|
constexpr auto dr = magic_enum::enum_value<Directions>(3);
|
|
REQUIRE(magic_enum::enum_value<Directions>(0) == Directions::Left);
|
|
REQUIRE(magic_enum::enum_value<Directions>(1) == Directions::Down);
|
|
REQUIRE(magic_enum::enum_value<Directions>(2) == Directions::Up);
|
|
REQUIRE(dr == Directions::Right);
|
|
|
|
constexpr auto nt = magic_enum::enum_value<number>(2);
|
|
REQUIRE(magic_enum::enum_value<number>(0) == number::one);
|
|
REQUIRE(magic_enum::enum_value<number>(1) == number::two);
|
|
REQUIRE(nt == number::three);
|
|
}
|
|
|
|
TEST_CASE("enum_values") {
|
|
constexpr auto s1 = magic_enum::enum_values<Color>();
|
|
REQUIRE(s1 == std::array<Color, 3>{{Color::RED, Color::GREEN, Color::BLUE}});
|
|
|
|
constexpr auto s2 = magic_enum::enum_values<Numbers>();
|
|
REQUIRE(s2 == std::array<Numbers, 3>{{Numbers::one, Numbers::two, Numbers::three}});
|
|
|
|
constexpr auto s3 = magic_enum::enum_values<Directions>();
|
|
REQUIRE(s3 == std::array<Directions, 4>{{Directions::Left, Directions::Down, Directions::Up, Directions::Right}});
|
|
|
|
constexpr auto s4 = magic_enum::enum_values<number>();
|
|
REQUIRE(s4 == std::array<number, 3>{{number::one, number::two, number::three}});
|
|
}
|
|
|
|
TEST_CASE("enum_count") {
|
|
constexpr auto s1 = magic_enum::enum_count<Color>();
|
|
REQUIRE(s1 == 3);
|
|
|
|
constexpr auto s2 = magic_enum::enum_count<Numbers>();
|
|
REQUIRE(s2 == 3);
|
|
|
|
constexpr auto s3 = magic_enum::enum_count<Directions>();
|
|
REQUIRE(s3 == 4);
|
|
|
|
constexpr auto s4 = magic_enum::enum_count<number>();
|
|
REQUIRE(s4 == 3);
|
|
}
|
|
|
|
TEST_CASE("enum_name") {
|
|
constexpr Color cr = Color::RED;
|
|
constexpr auto cr_name = magic_enum::enum_name(cr);
|
|
Color cm[3] = {Color::RED, Color::GREEN, Color::BLUE};
|
|
REQUIRE(cr_name == "RED");
|
|
REQUIRE(magic_enum::enum_name(Color::BLUE) == "BLUE");
|
|
REQUIRE(magic_enum::enum_name(cm[1]) == "GREEN");
|
|
REQUIRE(magic_enum::enum_name(static_cast<Color>(0)).empty());
|
|
|
|
constexpr Numbers no = Numbers::one;
|
|
constexpr auto no_name = magic_enum::enum_name(no);
|
|
REQUIRE(no_name == "one");
|
|
REQUIRE(magic_enum::enum_name(Numbers::two) == "two");
|
|
REQUIRE(magic_enum::enum_name(Numbers::three) == "three");
|
|
REQUIRE(magic_enum::enum_name(Numbers::many).empty());
|
|
REQUIRE(magic_enum::enum_name(static_cast<Numbers>(0)).empty());
|
|
|
|
constexpr Directions dr = Directions::Right;
|
|
constexpr auto dr_name = magic_enum::enum_name(dr);
|
|
REQUIRE(magic_enum::enum_name(Directions::Up) == "Up");
|
|
REQUIRE(magic_enum::enum_name(Directions::Down) == "Down");
|
|
REQUIRE(dr_name == "Right");
|
|
REQUIRE(magic_enum::enum_name(Directions::Left) == "Left");
|
|
REQUIRE(magic_enum::enum_name(static_cast<Directions>(0)).empty());
|
|
|
|
constexpr number nt = number::three;
|
|
constexpr auto nt_name = magic_enum::enum_name(nt);
|
|
REQUIRE(magic_enum::enum_name(number::one) == "one");
|
|
REQUIRE(magic_enum::enum_name(number::two) == "two");
|
|
REQUIRE(nt_name == "three");
|
|
REQUIRE(magic_enum::enum_name(number::zero).empty());
|
|
REQUIRE(magic_enum::enum_name(number::four).empty());
|
|
REQUIRE(magic_enum::enum_name(static_cast<number>(0)).empty());
|
|
}
|
|
|
|
TEST_CASE("enum_names") {
|
|
constexpr auto s1 = magic_enum::enum_names<Color>();
|
|
REQUIRE(s1 == std::array<std::string_view, 3>{{"RED", "GREEN", "BLUE"}});
|
|
|
|
constexpr auto s2 = magic_enum::enum_names<Numbers>();
|
|
REQUIRE(s2 == std::array<std::string_view, 3>{{"one", "two", "three"}});
|
|
|
|
constexpr auto s3 = magic_enum::enum_names<Directions>();
|
|
REQUIRE(s3 == std::array<std::string_view, 4>{{"Left", "Down", "Up", "Right"}});
|
|
|
|
constexpr auto s4 = magic_enum::enum_names<number>();
|
|
REQUIRE(s4 == std::array<std::string_view, 3>{{"one", "two", "three"}});
|
|
}
|
|
|
|
TEST_CASE("enum_entries") {
|
|
constexpr auto s1 = magic_enum::enum_entries<Color>();
|
|
REQUIRE(s1 == std::array<std::pair<Color, std::string_view>, 3>{{{Color::RED, "RED"}, {Color::GREEN, "GREEN"}, {Color::BLUE, "BLUE"}}});
|
|
|
|
constexpr auto s2 = magic_enum::enum_entries<Numbers>();
|
|
REQUIRE(s2 == std::array<std::pair<Numbers, std::string_view>, 3>{{{Numbers::one, "one"}, {Numbers::two, "two"}, {Numbers::three, "three"}}});
|
|
|
|
constexpr auto s3 = magic_enum::enum_entries<Directions>();
|
|
REQUIRE(s3 == std::array<std::pair<Directions, std::string_view>, 4>{{{Directions::Left, "Left"}, {Directions::Down, "Down"}, {Directions::Up, "Up"}, {Directions::Right, "Right"}}});
|
|
|
|
constexpr auto s4 = magic_enum::enum_entries<number>();
|
|
REQUIRE(s4 == std::array<std::pair<number, std::string_view>, 3>{{{number::one, "one"}, {number::two, "two"}, {number::three, "three"}}});
|
|
}
|
|
|
|
TEST_CASE("operator<<") {
|
|
auto test_ostream = [](auto e, std::string_view name) {
|
|
using namespace magic_enum::ops;
|
|
std::stringstream ss;
|
|
ss << e;
|
|
REQUIRE(ss.str() == name);
|
|
};
|
|
|
|
test_ostream(Color::RED, "RED");
|
|
test_ostream(Color::GREEN, "GREEN");
|
|
test_ostream(Color::BLUE, "BLUE");
|
|
test_ostream(static_cast<Color>(0), "");
|
|
|
|
test_ostream(Numbers::one, "one");
|
|
test_ostream(Numbers::two, "two");
|
|
test_ostream(Numbers::three, "three");
|
|
test_ostream(Numbers::many, "");
|
|
test_ostream(static_cast<Numbers>(0), "");
|
|
|
|
test_ostream(Directions::Up, "Up");
|
|
test_ostream(Directions::Down, "Down");
|
|
test_ostream(Directions::Right, "Right");
|
|
test_ostream(Directions::Left, "Left");
|
|
test_ostream(static_cast<Directions>(0), "");
|
|
|
|
test_ostream(number::one, "one");
|
|
test_ostream(number::two, "two");
|
|
test_ostream(number::three, "three");
|
|
test_ostream(number::zero, "");
|
|
test_ostream(number::four, "");
|
|
test_ostream(static_cast<number>(0), "");
|
|
}
|
|
|
|
TEST_CASE("type_traits") {
|
|
REQUIRE_FALSE(magic_enum::is_unscoped_enum_v<Color>);
|
|
REQUIRE_FALSE(magic_enum::is_unscoped_enum_v<Numbers>);
|
|
REQUIRE(magic_enum::is_unscoped_enum_v<Directions>);
|
|
REQUIRE(magic_enum::is_unscoped_enum_v<number>);
|
|
|
|
REQUIRE(magic_enum::is_scoped_enum_v<Color>);
|
|
REQUIRE(magic_enum::is_scoped_enum_v<Numbers>);
|
|
REQUIRE_FALSE(magic_enum::is_scoped_enum_v<Directions>);
|
|
REQUIRE_FALSE(magic_enum::is_scoped_enum_v<number>);
|
|
}
|