diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index c3fd695..9ceb1ab 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -43,11 +43,19 @@ make_test(test_flags.cpp test_flags-cpp17 c++17)
 make_test(test_aliases.cpp test_aliases-cpp17 c++17)
 make_test(test_containers.cpp test_containers-cpp17 c++17)
 
+if(MAGIC_ENUM_OPT_ENABLE_NONASCII)
+  make_test(test_nonascii.cpp test_nonascii-cpp17 c++17)
+endif()
+
+
 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)
     make_test(test_containers.cpp test_containers-cpp20 c++20)
+    if(MAGIC_ENUM_OPT_ENABLE_NONASCII)
+      make_test(test_nonascii.cpp test_nonascii-cpp20 c++20)
+    endif()
 endif()
 
 if(HAS_CPP23_FLAG)
@@ -55,6 +63,9 @@ if(HAS_CPP23_FLAG)
     make_test(test_flags.cpp test_flags-cpp23 c++23)
     make_test(test_aliases.cpp test_aliases-cpp23 c++23)
     make_test(test_containers.cpp test_containers-cpp23 c++23)
+    if(MAGIC_ENUM_OPT_ENABLE_NONASCII)
+      make_test(test_nonascii.cpp test_nonascii-cpp23 c++23)
+    endif()
 endif()
 
 if(HAS_CPPLATEST_FLAG)
@@ -62,4 +73,7 @@ if(HAS_CPPLATEST_FLAG)
     make_test(test_flags.cpp test_flags-cpplatest c++latest)
     make_test(test_aliases.cpp test_aliases-cpplatest c++latest)
     make_test(test_containers.cpp test_containers-cpplatest c++latest)
+    if(MAGIC_ENUM_OPT_ENABLE_NONASCII)
+      make_test(test_nonascii.cpp test_nonascii-cpplatest c++latest)
+    endif()
 endif()
diff --git a/test/test.cpp b/test/test.cpp
index 5a394e5..2687c7b 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -50,10 +50,6 @@ enum class Numbers : int { one = 1, two, three, many = 127 };
 
 enum Directions { Up = 85, Down = -42, Right = 120, Left = -120 };
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-enum class Language : int { 日本語 = 10, 한국어 = 20, English = 30, 😃 = 40 };
-#endif
-
 enum number : unsigned long {
   one = 100,
   two = 200,
@@ -132,14 +128,7 @@ TEST_CASE("enum_cast") {
     REQUIRE(enum_cast<Directions>("Left").value() == Directions::Left);
     REQUIRE_FALSE(enum_cast<Directions>("None").has_value());
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr auto lang = enum_cast<Language>("日本語");
-    REQUIRE(enum_cast<Language&>("한국어").value() == Language::한국어);
-    REQUIRE(enum_cast<const Language>("English").value() == Language::English);
-    REQUIRE(lang.value() == Language::日本語);
-    REQUIRE(enum_cast<Language>("😃").value() == Language::😃);
-    REQUIRE_FALSE(enum_cast<Language>("Französisch").has_value());
-#else // !defined(MAGIC_ENUM_ENABLE_NONASCII)
+#if !defined(MAGIC_ENUM_ENABLE_NONASCII)
     constexpr auto dr2 = enum_cast<Directions>("RIGHT", case_insensitive);
     REQUIRE(dr2.value() == Directions::Right);
     REQUIRE(enum_cast<Directions&>("up", case_insensitive).value() == Directions::Up);
@@ -186,15 +175,6 @@ TEST_CASE("enum_cast") {
     REQUIRE(enum_cast<Directions>(-120).value() == Directions::Left);
     REQUIRE_FALSE(enum_cast<Directions>(0).has_value());
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr auto lang = enum_cast<Language>(10);
-    REQUIRE(enum_cast<Language&>(20).value() == Language::한국어);
-    REQUIRE(enum_cast<const Language>(30).value() == Language::English);
-    REQUIRE(lang.value() == Language::日本語);
-    REQUIRE(enum_cast<Language>(40).value() == Language::😃);
-    REQUIRE_FALSE(enum_cast<Language>(0).has_value());
-#endif
-
     constexpr auto nt = enum_cast<number>(300);
     REQUIRE(enum_cast<number>(100).value() == number::one);
     REQUIRE(enum_cast<number>(200).value() == number::two);
@@ -231,16 +211,6 @@ TEST_CASE("enum_integer") {
   REQUIRE(dr == 120);
   REQUIRE(enum_integer(static_cast<Directions>(0)) == 0);
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr auto lang = enum_integer(Language::日本語);
-    Language korean = Language::한국어;
-    REQUIRE(enum_integer<Language&>(korean) == 20);
-    REQUIRE(enum_integer<const Language>(Language::English) == 30);
-    REQUIRE(enum_integer(Language::😃) == 40);
-    REQUIRE(lang == 10);
-    REQUIRE(enum_integer(static_cast<Language>(0)) == 0);
-#endif
-
   constexpr auto nt = enum_integer(number::three);
   REQUIRE(enum_integer(number::one) == 100);
   REQUIRE(enum_integer(number::two) == 200);
@@ -278,16 +248,6 @@ TEST_CASE("enum_index") {
   REQUIRE(dr.value() == 3);
   REQUIRE_FALSE(enum_index(static_cast<Directions>(0)).has_value());
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr auto lang = enum_index<Language>(Language::日本語);
-    Language korean = Language::한국어;
-    REQUIRE(enum_index<Language&>(korean) == 1);
-    REQUIRE(enum_index<const Language>(Language::English).value() == 2);
-    REQUIRE(enum_index(Language::😃) == 3);
-    REQUIRE(lang.value() == 0);
-    REQUIRE_FALSE(enum_index(static_cast<Language>(0)).has_value());
-#endif
-
   constexpr auto nt = enum_index(number::three);
   REQUIRE(enum_index<number::one>() == 0);
   REQUIRE(enum_index(number::one).value() == 0);
@@ -324,16 +284,6 @@ TEST_CASE("enum_contains") {
     REQUIRE(dr);
     REQUIRE_FALSE(enum_contains(static_cast<Directions>(0)));
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr auto lang = enum_contains(Language::日本語);
-    Language korean = Language::한국어;
-    REQUIRE(enum_contains<Language&>(korean));
-    REQUIRE(enum_contains<const Language>(Language::English));
-    REQUIRE(enum_contains(Language::😃));
-    REQUIRE(lang);
-    REQUIRE_FALSE(enum_contains(static_cast<Directions>(0)));
-#endif
-
     constexpr auto nt = enum_contains(number::three);
     REQUIRE(enum_contains(number::one));
     REQUIRE(enum_contains<number&>(number::two));
@@ -364,14 +314,6 @@ TEST_CASE("enum_contains") {
     REQUIRE(enum_contains<Directions>(Directions::Up));
     REQUIRE_FALSE(enum_contains<Directions>(static_cast<Directions>(0)));
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr auto lang = enum_integer(Language::日本語);
-    REQUIRE(enum_contains<Language&>(lang));
-    REQUIRE(enum_contains<const Language>(Language::한국어));
-    REQUIRE(enum_contains<Language>(Language::😃));
-    REQUIRE_FALSE(enum_contains<Language>(static_cast<Language>(0)));
-#endif
-
     constexpr auto nt = enum_contains<number>(number::three);
     REQUIRE(enum_contains<number>(number::one));
     REQUIRE(enum_contains<number>(100));
@@ -408,14 +350,7 @@ TEST_CASE("enum_contains") {
     REQUIRE(enum_contains<Directions>("Left"));
     REQUIRE_FALSE(enum_contains<Directions>("None"));
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    auto lang = std::string{"日本語"};
-    REQUIRE(enum_contains<Language&>("한국어"));
-    REQUIRE(enum_contains<Language>("English"));
-    REQUIRE(enum_contains<const Language>(lang));
-    REQUIRE(enum_contains<Language>("😃"));
-    REQUIRE_FALSE(enum_contains<Language>("None"));
-#else
+#if !defined(MAGIC_ENUM_ENABLE_NONASCII)
     auto dr2 = std::string{"RIGHT"};
     REQUIRE(enum_contains<const Directions>(dr2, case_insensitive));
     REQUIRE(enum_contains<Directions&>("up", case_insensitive));
@@ -464,14 +399,6 @@ TEST_CASE("enum_value") {
   REQUIRE(enum_value<Directions, 2>() == Directions::Up);
   REQUIRE(enum_value<Directions, 3>() == Directions::Right);
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr auto lang = enum_value<Language>(3);
-    REQUIRE(enum_value<Language&>(0) == Language::日本語);
-    REQUIRE(enum_value<const Language>(1) == Language::한국어);
-    REQUIRE(enum_value<Language>(2) == Language::English);
-    REQUIRE(lang == Language::😃);
-#endif
-
   constexpr auto nt = enum_value<number>(2);
   REQUIRE(enum_value<number>(0) == number::one);
   REQUIRE(enum_value<number>(1) == number::two);
@@ -505,11 +432,6 @@ TEST_CASE("enum_values") {
 
   constexpr auto& s6 = enum_values<MaxUsedAsInvalid>();
   REQUIRE(s6 == std::array<MaxUsedAsInvalid, 2>{{MaxUsedAsInvalid::ONE, MaxUsedAsInvalid::TWO}});
-
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  constexpr auto& s7 = enum_values<const Language>();
-  REQUIRE(s7 == std::array<Language, 4>{{Language::日本語, Language::한국어, Language::English, Language::😃}});
-#endif
 }
 
 TEST_CASE("enum_count") {
@@ -531,10 +453,6 @@ TEST_CASE("enum_count") {
   constexpr auto s6 = enum_count<MaxUsedAsInvalid>();
   REQUIRE(s6 == 2);
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  constexpr auto s7 = enum_count<Language>();
-  REQUIRE(s7 == 4);
-#endif
 }
 
 TEST_CASE("enum_name") {
@@ -565,17 +483,6 @@ TEST_CASE("enum_name") {
     REQUIRE(enum_name(Directions::Left) == "Left");
     REQUIRE(enum_name(static_cast<Directions>(0)).empty());
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr Language lang = Language::日本語;
-    constexpr auto lang_name = enum_name(lang);
-    Language lk = Language::한국어;
-    REQUIRE(enum_name<Language&>(lk) == "한국어");
-    REQUIRE(enum_name<const Language>(Language::English) == "English");
-    REQUIRE(lang_name == "日本語");
-    REQUIRE(enum_name(Language::😃) == "😃");
-    REQUIRE(enum_name(static_cast<Language>(0)).empty());
-#endif
-
     constexpr number nt = number::three;
     constexpr auto nt_name = enum_name(nt);
     REQUIRE(enum_name(number::one) == "one");
@@ -609,15 +516,6 @@ TEST_CASE("enum_name") {
     REQUIRE(dr_name == "Right");
     REQUIRE(enum_name<Directions::Left>() == "Left");
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr Language lang = Language::日本語;
-    constexpr auto lang_name = enum_name<lang>();
-    REQUIRE(enum_name<Language::한국어>() == "한국어");
-    REQUIRE(enum_name<Language::English>() == "English");
-    REQUIRE(lang_name == "日本語");
-    REQUIRE(enum_name<Language::😃>() == "😃");
-#endif
-
     constexpr number nt = number::three;
     constexpr auto nt_name = enum_name<nt>();
     REQUIRE(enum_name<number::one>() == "one");
@@ -644,11 +542,6 @@ TEST_CASE("enum_names") {
 
   constexpr auto& s4 = enum_names<number>();
   REQUIRE(s4 == std::array<std::string_view, 3>{{"one", "two", "three"}});
-
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  constexpr auto& s5 = enum_names<const Language>();
-  REQUIRE(s5 == std::array<std::string_view, 4>{{"日本語", "한국어", "English", "😃"}});
-#endif
 }
 
 TEST_CASE("enum_entries") {
@@ -665,11 +558,6 @@ TEST_CASE("enum_entries") {
 
   constexpr auto& s4 = enum_entries<number>();
   REQUIRE(s4 == std::array<std::pair<number, std::string_view>, 3>{{{number::one, "one"}, {number::two, "two"}, {number::three, "three"}}});
-
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  constexpr auto& s5 = enum_entries<const Language>();
-  REQUIRE(s5 == std::array<std::pair<Language, std::string_view>, 4>{{{Language::日本語, "日本語"}, {Language::한국어, "한국어"}, {Language::English, "English"}, {Language::😃, "😃"}}});
-#endif
 }
 
 TEST_CASE("ostream_operators") {
@@ -701,15 +589,6 @@ TEST_CASE("ostream_operators") {
   test_ostream(static_cast<Directions>(0), "0");
   test_ostream(std::make_optional(static_cast<Directions>(0)), "0");
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  test_ostream(std::make_optional(Language::日本語), "日本語");
-  test_ostream(Language::한국어, "한국어");
-  test_ostream(Language::English, "English");
-  test_ostream(Language::😃, "😃");
-  test_ostream(static_cast<Language>(0), "0");
-  test_ostream(std::make_optional(static_cast<Language>(0)), "0");
-#endif
-
   test_ostream(std::make_optional(number::one), "one");
   test_ostream(number::two, "two");
   test_ostream(number::three, "three");
@@ -738,12 +617,6 @@ TEST_CASE("istream_operators") {
   test_istream(Directions::Right, "Right");
   test_istream(Directions::Left, "Left");
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  test_istream(Language::한국어, "한국어");
-  test_istream(Language::English, "English");
-  test_istream(Language::😃, "😃");
-#endif
-
   test_istream(number::two, "two");
   test_istream(number::three, "three");
 }
@@ -755,9 +628,6 @@ TEST_CASE("bitwise_operators") {
     REQUIRE(enum_integer(~Color::RED) == ~enum_integer(Color::RED));
     REQUIRE(enum_integer(~Numbers::one) == ~enum_integer(Numbers::one));
     REQUIRE(enum_integer(~Directions::Up) == ~enum_integer(Directions::Up));
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    REQUIRE(enum_integer(~Language::日本語) == ~enum_integer(Language::日本語));
-#endif
     REQUIRE(enum_integer(~number::one) == ~enum_integer(number::one));
   }
 
@@ -765,9 +635,6 @@ TEST_CASE("bitwise_operators") {
     REQUIRE(enum_integer(Color::RED | Color::BLUE) == (enum_integer(Color::RED) | enum_integer(Color::BLUE)));
     REQUIRE(enum_integer(Numbers::one | Numbers::two) == (enum_integer(Numbers::one) | enum_integer(Numbers::two)));
     REQUIRE(enum_integer(Directions::Up | Directions::Down) == (enum_integer(Directions::Up) | enum_integer(Directions::Down)));
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    REQUIRE(enum_integer(Language::日本語 | Language::한국어) == (enum_integer(Language::日本語) | enum_integer(Language::한국어)));
-#endif
     REQUIRE(enum_integer(number::one | number::two) == (enum_integer(number::one) | enum_integer(number::two)));
   }
 
@@ -775,9 +642,6 @@ TEST_CASE("bitwise_operators") {
     REQUIRE(enum_integer(Color::RED & Color::BLUE) == (enum_integer(Color::RED) & enum_integer(Color::BLUE)));
     REQUIRE(enum_integer(Numbers::one & Numbers::two) == (enum_integer(Numbers::one) & enum_integer(Numbers::two)));
     REQUIRE(enum_integer(Directions::Up & Directions::Down) == (enum_integer(Directions::Up) & enum_integer(Directions::Down)));
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    REQUIRE(enum_integer(Language::日本語 & Language::한국어) == (enum_integer(Language::日本語) & enum_integer(Language::한국어)));
-#endif
     REQUIRE(enum_integer(number::one & number::two) == (enum_integer(number::one) & enum_integer(number::two)));
   }
 
@@ -785,9 +649,6 @@ TEST_CASE("bitwise_operators") {
     REQUIRE(enum_integer(Color::RED ^ Color::BLUE) == (enum_integer(Color::RED) ^ enum_integer(Color::BLUE)));
     REQUIRE(enum_integer(Numbers::one ^ Numbers::two) == (enum_integer(Numbers::one) ^ enum_integer(Numbers::two)));
     REQUIRE(enum_integer(Directions::Up ^ Directions::Down) == (enum_integer(Directions::Up) ^ enum_integer(Directions::Down)));
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    REQUIRE(enum_integer(Language::日本語 ^ Language::한국어) == (enum_integer(Language::日本語) ^ enum_integer(Language::한국어)));
-#endif
     REQUIRE(enum_integer(number::one ^ number::two) == (enum_integer(number::one) ^ enum_integer(number::two)));
   }
 
@@ -807,12 +668,6 @@ TEST_CASE("bitwise_operators") {
     number x4 = number::one;
     x4 |= number::two;
     REQUIRE(enum_integer(x4) == (enum_integer(number::one) | enum_integer(number::two)));
-
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    Language x5 = Language::日本語;
-    x5 |= Language::한국어;
-    REQUIRE(enum_integer(x5) == (enum_integer(Language::日本語) | enum_integer(Language::한국어)));
-#endif
   }
 
   SECTION("operator&=") {
@@ -831,12 +686,6 @@ TEST_CASE("bitwise_operators") {
     number x4 = number::one;
     x4 &= number::two;
     REQUIRE(enum_integer(x4) == (enum_integer(number::one) & enum_integer(number::two)));
-
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    Language x5 = Language::日本語;
-    x5 &= Language::한국어;
-    REQUIRE(enum_integer(x5) == (enum_integer(Language::日本語) & enum_integer(Language::한국어)));
-#endif
   }
 
   SECTION("operator^=") {
@@ -855,12 +704,6 @@ TEST_CASE("bitwise_operators") {
     number x4 = number::one;
     x4 ^= number::two;
     REQUIRE(enum_integer(x4) == (enum_integer(number::one) ^ enum_integer(number::two)));
-
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    Language x5 = Language::日本語;
-    x5 ^= Language::한국어;
-    REQUIRE(enum_integer(x5) == (enum_integer(Language::日本語) ^ enum_integer(Language::한국어)));
-#endif
   }
 }
 
@@ -868,9 +711,6 @@ TEST_CASE("type_traits") {
   REQUIRE_FALSE(is_unscoped_enum_v<Color>);
   REQUIRE_FALSE(is_unscoped_enum_v<Numbers>);
   REQUIRE(is_unscoped_enum_v<Directions>);
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  REQUIRE_FALSE(is_unscoped_enum_v<Language>);
-#endif
   REQUIRE(is_unscoped_enum_v<number>);
 
   REQUIRE(is_scoped_enum_v<Color>);
@@ -883,9 +723,6 @@ TEST_CASE("enum_type_name") {
   REQUIRE(enum_type_name<Color&>() == "Color");
   REQUIRE(enum_type_name<const Numbers>() == "Numbers");
   REQUIRE(enum_type_name<const Directions&>() == "Directions");
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  REQUIRE(enum_type_name<const Language&>() == "Language");
-#endif
   REQUIRE(enum_type_name<number>() == "number");
 }
 
@@ -944,12 +781,6 @@ TEST_CASE("extrema") {
     REQUIRE(magic_enum::detail::reflected_min_v<Directions, false> == MAGIC_ENUM_RANGE_MIN);
     REQUIRE(magic_enum::detail::min_v<Directions> == -120);
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    REQUIRE(magic_enum::customize::enum_range<Language>::min == MAGIC_ENUM_RANGE_MIN);
-    REQUIRE(magic_enum::detail::reflected_min_v<Language, false> == MAGIC_ENUM_RANGE_MIN);
-    REQUIRE(magic_enum::detail::min_v<Language> == 10);
-#endif
-
     REQUIRE(magic_enum::customize::enum_range<number>::min == 100);
     REQUIRE(magic_enum::detail::reflected_min_v<number, false> == 100);
     REQUIRE(magic_enum::detail::min_v<number> == 100);
@@ -978,12 +809,6 @@ TEST_CASE("extrema") {
     REQUIRE(magic_enum::detail::reflected_max_v<Directions, false> == MAGIC_ENUM_RANGE_MAX);
     REQUIRE(magic_enum::detail::max_v<Directions> == 120);
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    REQUIRE(magic_enum::customize::enum_range<Language>::max == MAGIC_ENUM_RANGE_MAX);
-    REQUIRE(magic_enum::detail::reflected_max_v<Language, false> == MAGIC_ENUM_RANGE_MAX);
-    REQUIRE(magic_enum::detail::max_v<Language> == 40);
-#endif
-
     REQUIRE(magic_enum::customize::enum_range<number>::max == 300);
     REQUIRE(magic_enum::detail::reflected_max_v<number, false> == 300);
     REQUIRE(magic_enum::detail::max_v<number> == 300);
diff --git a/test/test_flags.cpp b/test/test_flags.cpp
index fb0f28c..4eacc30 100644
--- a/test/test_flags.cpp
+++ b/test/test_flags.cpp
@@ -56,15 +56,6 @@ enum Directions : std::uint64_t {
   Right = std::uint64_t{1} << 63,
 };
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-enum class Language : int {
-  日本語 = 1 << 1,
-  한국어 = 1 << 2,
-  English = 1 << 3,
-  😃 = 1 << 4
-};
-#endif
-
 enum number : unsigned long {
   one = 1 << 1,
   two = 1 << 2,
@@ -121,15 +112,6 @@ TEST_CASE("enum_cast") {
     REQUIRE(enum_cast<Directions>("Left").value() == Directions::Left);
     REQUIRE_FALSE(enum_cast<Directions>("None").has_value());
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr auto lang = enum_cast<Language>("日本語");
-    REQUIRE(enum_cast<Language&>("한국어").value() == Language::한국어);
-    REQUIRE(enum_cast<const Language>("English").value() == Language::English);
-    REQUIRE(lang.value() == Language::日本語);
-    REQUIRE(enum_cast<Language>("😃").value() == Language::😃);
-    REQUIRE_FALSE(enum_cast<Language>("None").has_value());
-#endif
-
     constexpr auto nto = enum_flags_cast<number>("three|one");
     REQUIRE(enum_cast<number>("one").value() == number::one);
     REQUIRE(enum_cast<number>("two").value() == number::two);
@@ -172,15 +154,6 @@ TEST_CASE("enum_cast") {
     REQUIRE(enum_cast<Directions>(std::uint64_t{1} << 10).value() == Directions::Left);
     REQUIRE_FALSE(enum_cast<Directions>(0).has_value());
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr auto lang = enum_cast<Language>(1 << 1);
-    REQUIRE(enum_cast<Language&>(1 << 2).value() == Language::한국어);
-    REQUIRE(enum_cast<const Language>(1 << 3).value() == Language::English);
-    REQUIRE(lang.value() == Language::日本語);
-    REQUIRE(enum_cast<Language>(1 << 4).value() == Language::😃);
-    REQUIRE_FALSE(enum_cast<Language>(0).has_value());
-#endif
-
     constexpr auto nto = enum_flags_cast<number>(2 | 8);
     REQUIRE(enum_cast<number>(1 << 1).value() == number::one);
     REQUIRE(enum_cast<number>(1 << 2).value() == number::two);
@@ -218,16 +191,6 @@ TEST_CASE("enum_index") {
   REQUIRE(dr.value() == 3);
   REQUIRE_FALSE(enum_index(static_cast<Directions>(0)).has_value());
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr auto lang = enum_index<Language>(Language::日本語);
-    Language korean = Language::한국어;
-    REQUIRE(enum_index<Language&>(korean).value() == 1);
-    REQUIRE(enum_index<const Language>(Language::English).value() == 2);
-    REQUIRE(enum_index(Language::😃).value() == 3);
-    REQUIRE(lang.value() == 0);
-    REQUIRE_FALSE(enum_index(static_cast<Language>(0)).has_value());
-#endif
-
   constexpr auto nto = enum_index(number::three | number::one);
   REQUIRE(enum_index(number::one).value() == 0);
   REQUIRE(enum_index(number::two).value() == 1);
@@ -274,16 +237,6 @@ TEST_CASE("enum_contains") {
     REQUIRE(dr);
     REQUIRE_FALSE(enum_contains(static_cast<Directions>(0)));
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr auto lang = enum_index<Language>(Language::日本語);
-    Language korean = Language::한국어;
-    REQUIRE(enum_contains<Language&>(korean));
-    REQUIRE(enum_contains<const Language>(Language::English));
-    REQUIRE(enum_contains(Language::😃));
-    REQUIRE(lang);
-    REQUIRE_FALSE(enum_contains(static_cast<Language>(0)));
-#endif
-
     constexpr auto nto = enum_contains(number::three | number::one);
     REQUIRE(enum_contains(number::one));
     REQUIRE(enum_contains<number&>(number::two));
@@ -327,15 +280,6 @@ TEST_CASE("enum_contains") {
     REQUIRE(enum_contains<Directions>(std::uint64_t{1} << 31));
     REQUIRE_FALSE(enum_contains<Directions>(static_cast<Directions>(0)));
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr auto lang = enum_contains<Language&>(1 << 1);
-    REQUIRE(lang);
-    REQUIRE(enum_contains<const Language>(1 << 2));
-    REQUIRE(enum_contains<Language>(1 << 3));
-    REQUIRE(enum_contains<Language>(1 << 4));
-    REQUIRE_FALSE(enum_contains(static_cast<Language>(0)));
-#endif
-
     constexpr auto nto = enum_contains<number>(8 | 2);
     REQUIRE(enum_contains<number>(1 << 1));
     REQUIRE(enum_contains<number>(1 << 2));
@@ -384,15 +328,6 @@ TEST_CASE("enum_contains") {
     REQUIRE(enum_contains<Directions>("Left"));
     REQUIRE_FALSE(enum_contains<Directions>("None"));
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    auto lang = std::string{"日本語"};
-    REQUIRE(enum_contains<Language&>("한국어"));
-    REQUIRE(enum_contains<Language>("English"));
-    REQUIRE(enum_contains<const Language>(lang));
-    REQUIRE(enum_contains<Language>("😃"));
-    REQUIRE_FALSE(enum_contains<Language>("None"));
-#endif
-
     constexpr auto nto = enum_contains<number>("three|one");
     REQUIRE(enum_contains<number>("one"));
     REQUIRE(enum_contains<number>("two"));
@@ -437,14 +372,6 @@ TEST_CASE("enum_value") {
   REQUIRE(enum_value<Directions, 2>() == Directions::Up);
   REQUIRE(enum_value<Directions, 3>() == Directions::Right);
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  constexpr auto lang = enum_value<Language>(3);
-  REQUIRE(enum_value<Language&>(0) == Language::日本語);
-  REQUIRE(enum_value<const Language>(1) == Language::한국어);
-  REQUIRE(enum_value<Language>(2) == Language::English);
-  REQUIRE(lang == Language::😃);
-#endif
-
   constexpr auto nt = enum_value<number>(2);
   REQUIRE(enum_value<number>(0) == number::one);
   REQUIRE(enum_value<number>(1) == number::two);
@@ -471,11 +398,6 @@ TEST_CASE("enum_values") {
 
   constexpr auto& s4 = enum_values<number>();
   REQUIRE(s4 == std::array<number, 4>{{number::one, number::two, number::three, number::four}});
-
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  constexpr auto& s5 = enum_values<const Language>();
-  REQUIRE(s5 == std::array<Language, 4>{{Language::日本語, Language::한국어, Language::English, Language::😃}});
-#endif
 }
 
 TEST_CASE("enum_count") {
@@ -490,11 +412,6 @@ TEST_CASE("enum_count") {
 
   constexpr auto s4 = enum_count<number>();
   REQUIRE(s4 == 4);
-
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  constexpr auto s5 = enum_count<Language>();
-  REQUIRE(s5 == 4);
-#endif
 }
 
 TEST_CASE("enum_name") {
@@ -530,17 +447,6 @@ TEST_CASE("enum_name") {
     REQUIRE(enum_name(Directions::Right | Directions::Up | Directions::Left | Directions::Down).empty());
     REQUIRE(enum_name(static_cast<Directions>(0)).empty());
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    constexpr Language lang = Language::日本語;
-    constexpr auto lang_name = enum_name(lang);
-    Language lk = Language::한국어;
-    REQUIRE(enum_name<Language&>(lk) == "한국어");
-    REQUIRE(enum_name<const Language>(Language::English) == "English");
-    REQUIRE(lang_name == "日本語");
-    REQUIRE(enum_name(Language::😃) == "😃");
-    REQUIRE(enum_name(static_cast<Language>(0)).empty());
-#endif
-
     constexpr number nto = number::three | number::one;
     constexpr auto nto_name = enum_name(nto);
     REQUIRE(enum_name(number::one) == "one");
@@ -584,17 +490,6 @@ TEST_CASE("enum_flags_name") {
   REQUIRE(enum_flags_name(Directions::Right | Directions::Up | Directions::Left | Directions::Down) == "Left|Down|Up|Right");
   REQUIRE(enum_flags_name(static_cast<Directions>(0)).empty());
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  constexpr Language lang = Language::日本語;
-  auto lang_name = enum_flags_name(lang);
-  Language lk = Language::한국어;
-  REQUIRE(enum_flags_name<Language&>(lk) == "한국어");
-  REQUIRE(enum_flags_name<const Language>(Language::English) == "English");
-  REQUIRE(lang_name == "日本語");
-  REQUIRE(enum_flags_name(Language::😃) == "😃");
-  REQUIRE(enum_flags_name(static_cast<Language>(0)).empty());
-#endif
-
   constexpr number nto = number::three | number::one;
   auto nto_name = enum_flags_name(nto);
   REQUIRE(enum_flags_name(number::one) == "one");
@@ -619,11 +514,6 @@ TEST_CASE("enum_names") {
 
   constexpr auto& s4 = enum_names<number>();
   REQUIRE(s4 == std::array<std::string_view, 4>{{"one", "two", "three", "four"}});
-
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  constexpr auto& s5 = enum_names<const Language>();
-  REQUIRE(s5 == std::array<std::string_view, 4>{{"日本語", "한국어", "English", "😃"}});
-#endif
 }
 
 TEST_CASE("enum_entries") {
@@ -640,11 +530,6 @@ TEST_CASE("enum_entries") {
 
   constexpr auto& s4 = enum_entries<number>();
   REQUIRE(s4 == std::array<std::pair<number, std::string_view>, 4>{{{number::one, "one"}, {number::two, "two"}, {number::three, "three"}, {number::four, "four"}}});
-
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  constexpr auto& s5 = enum_entries<const Language>();
-  REQUIRE(s5 == std::array<std::pair<Language, std::string_view>, 4>{{{Language::日本語, "日本語"}, {Language::한국어, "한국어"}, {Language::English, "English"}, {Language::😃, "😃"}}});
-#endif
 }
 
 TEST_CASE("ostream_operators") {
@@ -678,15 +563,6 @@ TEST_CASE("ostream_operators") {
   test_ostream(static_cast<Directions>(0), "0");
   test_ostream(std::make_optional(static_cast<Directions>(0)), "0");
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  test_ostream(std::make_optional(Language::日本語), "日本語");
-  test_ostream(Language::한국어, "한국어");
-  test_ostream(Language::English, "English");
-  test_ostream(Language::😃, "😃");
-  test_ostream(static_cast<Language>(0), "0");
-  test_ostream(std::make_optional(static_cast<Language>(0)), "0");
-#endif
-
   test_ostream(std::make_optional(number::one), "one");
   test_ostream(number::two, "two");
   test_ostream(number::three, "three");
@@ -720,12 +596,6 @@ TEST_CASE("istream_operators") {
   test_istream(Directions::Left, "Left");
   test_istream(Directions::Right | Directions::Left, "Left|Right");
 
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-  test_istream(Language::한국어, "한국어");
-  test_istream(Language::English, "English");
-  test_istream(Language::😃, "😃");
-#endif
-
   test_istream(number::two, "two");
   test_istream(number::three, "three");
   test_istream(number::four, "four");
@@ -737,9 +607,6 @@ TEST_CASE("bitwise_operators") {
     REQUIRE(enum_integer(~Color::RED) == ~enum_integer(Color::RED));
     REQUIRE(enum_integer(~Numbers::one) == ~enum_integer(Numbers::one));
     REQUIRE(enum_integer(~Directions::Up) == ~enum_integer(Directions::Up));
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    REQUIRE(enum_integer(~Language::日本語) == ~enum_integer(Language::日本語));
-#endif
     REQUIRE(enum_integer(~number::one) == ~enum_integer(number::one));
   }
 
@@ -747,9 +614,6 @@ TEST_CASE("bitwise_operators") {
     REQUIRE(enum_integer(Color::RED | Color::BLUE) == (enum_integer(Color::RED) | enum_integer(Color::BLUE)));
     REQUIRE(enum_integer(Numbers::one | Numbers::two) == (enum_integer(Numbers::one) | enum_integer(Numbers::two)));
     REQUIRE(enum_integer(Directions::Up | Directions::Down) == (enum_integer(Directions::Up) | enum_integer(Directions::Down)));
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    REQUIRE(enum_integer(Language::日本語 | Language::한국어) == (enum_integer(Language::日本語) | enum_integer(Language::한국어)));
-#endif
     REQUIRE(enum_integer(number::one | number::two) == (enum_integer(number::one) | enum_integer(number::two)));
   }
 
@@ -757,9 +621,6 @@ TEST_CASE("bitwise_operators") {
     REQUIRE(enum_integer(Color::RED & Color::BLUE) == (enum_integer(Color::RED) & enum_integer(Color::BLUE)));
     REQUIRE(enum_integer(Numbers::one & Numbers::two) == (enum_integer(Numbers::one) & enum_integer(Numbers::two)));
     REQUIRE(enum_integer(Directions::Up & Directions::Down) == (enum_integer(Directions::Up) & enum_integer(Directions::Down)));
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    REQUIRE(enum_integer(Language::日本語 & Language::한국어) == (enum_integer(Language::日本語) & enum_integer(Language::한국어)));
-#endif
     REQUIRE(enum_integer(number::one & number::two) == (enum_integer(number::one) & enum_integer(number::two)));
   }
 
@@ -767,9 +628,6 @@ TEST_CASE("bitwise_operators") {
     REQUIRE(enum_integer(Color::RED ^ Color::BLUE) == (enum_integer(Color::RED) ^ enum_integer(Color::BLUE)));
     REQUIRE(enum_integer(Numbers::one ^ Numbers::two) == (enum_integer(Numbers::one) ^ enum_integer(Numbers::two)));
     REQUIRE(enum_integer(Directions::Up ^ Directions::Down) == (enum_integer(Directions::Up) ^ enum_integer(Directions::Down)));
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    REQUIRE(enum_integer(Language::日本語 ^ Language::한국어) == (enum_integer(Language::日本語) ^ enum_integer(Language::한국어)));
-#endif
     REQUIRE(enum_integer(number::one ^ number::two) == (enum_integer(number::one) ^ enum_integer(number::two)));
   }
 
@@ -789,12 +647,6 @@ TEST_CASE("bitwise_operators") {
     number x4 = number::one;
     x4 |= number::two;
     REQUIRE(enum_integer(x4) == (enum_integer(number::one) | enum_integer(number::two)));
-
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    Language x5 = Language::日本語;
-    x5 |= Language::한국어;
-    REQUIRE(enum_integer(x5) == (enum_integer(Language::日本語) | enum_integer(Language::한국어)));
-#endif
   }
 
   SECTION("operator&=") {
@@ -813,12 +665,6 @@ TEST_CASE("bitwise_operators") {
     number x4 = number::one;
     x4 &= number::two;
     REQUIRE(enum_integer(x4) == (enum_integer(number::one) & enum_integer(number::two)));
-
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    Language x5 = Language::日本語;
-    x5 &= Language::한국어;
-    REQUIRE(enum_integer(x5) == (enum_integer(Language::日本語) & enum_integer(Language::한국어)));
-#endif
   }
 
   SECTION("operator^=") {
@@ -837,12 +683,6 @@ TEST_CASE("bitwise_operators") {
     number x4 = number::one;
     x4 ^= number::two;
     REQUIRE(enum_integer(x4) == (enum_integer(number::one) ^ enum_integer(number::two)));
-
-#if defined(MAGIC_ENUM_ENABLE_NONASCII)
-    Language x5 = Language::日本語;
-    x5 ^= Language::한국어;
-    REQUIRE(enum_integer(x5) == (enum_integer(Language::日本語) ^ enum_integer(Language::한국어)));
-#endif
   }
 }
 
diff --git a/test/test_nonascii.cpp b/test/test_nonascii.cpp
new file mode 100644
index 0000000..4afe6b7
--- /dev/null
+++ b/test/test_nonascii.cpp
@@ -0,0 +1,446 @@
+// 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.
+
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
+
+#undef  MAGIC_ENUM_RANGE_MIN
+#define MAGIC_ENUM_RANGE_MIN -120
+#undef  MAGIC_ENUM_RANGE_MAX
+#define MAGIC_ENUM_RANGE_MAX 120
+#include <magic_enum.hpp>
+#include <magic_enum_fuse.hpp>
+
+#include <array>
+#include <cctype>
+#include <string_view>
+#include <sstream>
+
+#if !defined(MAGIC_ENUM_ENABLE_NONASCII)
+#error ENABLE_NONASCII must be defined to run nonascii tests
+#endif
+
+enum class Language : int { 日本語 = 10, 한국어 = 20, English = 30, 😃 = 40 };
+
+enum class LanguageFlag : int {
+  日本語 = 1 << 1,
+  한국어 = 1 << 2,
+  English = 1 << 3,
+  😃 = 1 << 4
+};
+
+using namespace magic_enum;
+
+static_assert(is_magic_enum_supported, "magic_enum: Unsupported compiler (https://github.com/Neargye/magic_enum#compiler-compatibility).");
+
+TEST_CASE("enum_cast") {
+  SECTION("string") {
+      constexpr auto lang = enum_cast<Language>("日本語");
+      REQUIRE(enum_cast<Language&>("한국어").value() == Language::한국어);
+      REQUIRE(enum_cast<const Language>("English").value() == Language::English);
+      REQUIRE(lang.value() == Language::日本語);
+      REQUIRE(enum_cast<Language>("😃").value() == Language::😃);
+      REQUIRE_FALSE(enum_cast<Language>("Französisch").has_value());
+  }
+
+  SECTION("integer") {
+    constexpr auto lang = enum_cast<Language>(10);
+    REQUIRE(enum_cast<Language&>(20).value() == Language::한국어);
+    REQUIRE(enum_cast<const Language>(30).value() == Language::English);
+    REQUIRE(lang.value() == Language::日本語);
+    REQUIRE(enum_cast<Language>(40).value() == Language::😃);
+    REQUIRE_FALSE(enum_cast<Language>(0).has_value());
+  }
+}
+
+TEST_CASE("enum_integer") {
+    constexpr auto lang = enum_integer(Language::日本語);
+    Language korean = Language::한국어;
+    REQUIRE(enum_integer<Language&>(korean) == 20);
+    REQUIRE(enum_integer<const Language>(Language::English) == 30);
+    REQUIRE(enum_integer(Language::😃) == 40);
+    REQUIRE(lang == 10);
+    REQUIRE(enum_integer(static_cast<Language>(0)) == 0);
+}
+
+TEST_CASE("enum_index") {
+    constexpr auto lang = enum_index<Language>(Language::日本語);
+    Language korean = Language::한국어;
+    REQUIRE(enum_index<Language&>(korean) == 1);
+    REQUIRE(enum_index<const Language>(Language::English).value() == 2);
+    REQUIRE(enum_index(Language::😃) == 3);
+    REQUIRE(lang.value() == 0);
+    REQUIRE_FALSE(enum_index(static_cast<Language>(0)).has_value());
+}
+
+TEST_CASE("enum_contains") {
+  SECTION("value") {
+    constexpr auto lang = enum_contains(Language::日本語);
+    Language korean = Language::한국어;
+    REQUIRE(enum_contains<Language&>(korean));
+    REQUIRE(enum_contains<const Language>(Language::English));
+    REQUIRE(enum_contains(Language::😃));
+    REQUIRE(lang);
+  }
+
+  SECTION("integer") {
+    constexpr auto lang = enum_integer(Language::日本語);
+    REQUIRE(enum_contains<Language&>(lang));
+    REQUIRE(enum_contains<const Language>(Language::한국어));
+    REQUIRE(enum_contains<Language>(Language::😃));
+    REQUIRE_FALSE(enum_contains<Language>(static_cast<Language>(0)));
+  }
+
+  SECTION("string") {
+    auto lang = std::string{"日本語"};
+    REQUIRE(enum_contains<Language&>("한국어"));
+    REQUIRE(enum_contains<Language>("English"));
+    REQUIRE(enum_contains<const Language>(lang));
+    REQUIRE(enum_contains<Language>("😃"));
+    REQUIRE_FALSE(enum_contains<Language>("None"));
+  }
+}
+
+TEST_CASE("enum_value") {
+    constexpr auto lang = enum_value<Language>(3);
+    REQUIRE(enum_value<Language&>(0) == Language::日本語);
+    REQUIRE(enum_value<const Language>(1) == Language::한국어);
+    REQUIRE(enum_value<Language>(2) == Language::English);
+    REQUIRE(lang == Language::😃);
+}
+
+TEST_CASE("enum_values") {
+  constexpr auto& s7 = enum_values<const Language>();
+  REQUIRE(s7 == std::array<Language, 4>{{Language::日本語, Language::한국어, Language::English, Language::😃}});
+}
+
+TEST_CASE("enum_count") {
+  constexpr auto s7 = enum_count<Language>();
+  REQUIRE(s7 == 4);
+}
+
+TEST_CASE("enum_name") {
+  SECTION("automatic storage") {
+    constexpr Language lang = Language::日本語;
+    constexpr auto lang_name = enum_name(lang);
+    Language lk = Language::한국어;
+    REQUIRE(enum_name<Language&>(lk) == "한국어");
+    REQUIRE(enum_name<const Language>(Language::English) == "English");
+    REQUIRE(lang_name == "日本語");
+    REQUIRE(enum_name(Language::😃) == "😃");
+    REQUIRE(enum_name(static_cast<Language>(0)).empty());
+  }
+
+  SECTION("static storage") {
+    constexpr Language lang = Language::日本語;
+    constexpr auto lang_name = enum_name<lang>();
+    REQUIRE(enum_name<Language::한국어>() == "한국어");
+    REQUIRE(enum_name<Language::English>() == "English");
+    REQUIRE(lang_name == "日本語");
+    REQUIRE(enum_name<Language::😃>() == "😃");
+  }
+}
+
+TEST_CASE("enum_names") {
+  constexpr auto& s5 = enum_names<const Language>();
+  REQUIRE(s5 == std::array<std::string_view, 4>{{"日本語", "한국어", "English", "😃"}});
+}
+
+TEST_CASE("enum_entries") {
+  constexpr auto& s5 = enum_entries<const Language>();
+  REQUIRE(s5 == std::array<std::pair<Language, std::string_view>, 4>{{{Language::日本語, "日本語"}, {Language::한국어, "한국어"}, {Language::English, "English"}, {Language::😃, "😃"}}});
+}
+
+TEST_CASE("ostream_operators") {
+  auto test_ostream = [](auto e, std::string name) {
+    using namespace magic_enum::ostream_operators;
+    std::stringstream ss;
+    ss << e;
+    REQUIRE(ss);
+    REQUIRE(ss.str() == name);
+  };
+
+  test_ostream(std::make_optional(Language::日本語), "日本語");
+  test_ostream(Language::한국어, "한국어");
+  test_ostream(Language::English, "English");
+  test_ostream(Language::😃, "😃");
+  test_ostream(static_cast<Language>(0), "0");
+  test_ostream(std::make_optional(static_cast<Language>(0)), "0");
+}
+
+TEST_CASE("istream_operators") {
+  auto test_istream = [](const auto e, std::string name) {
+    using namespace magic_enum::istream_operators;
+    std::istringstream ss(name);
+    std::decay_t<decltype(e)> v;
+    ss >> v;
+    REQUIRE(ss);
+    REQUIRE(v == e);
+  };
+
+  test_istream(Language::한국어, "한국어");
+  test_istream(Language::English, "English");
+  test_istream(Language::😃, "😃");
+}
+
+TEST_CASE("bitwise_operators") {
+  using namespace magic_enum::bitwise_operators;
+
+  SECTION("operator^") {
+    REQUIRE(enum_integer(~Language::日本語) == ~enum_integer(Language::日本語));
+  }
+
+  SECTION("operator|") {
+    REQUIRE(enum_integer(Language::日本語 | Language::한국어) == (enum_integer(Language::日本語) | enum_integer(Language::한국어)));
+  }
+
+  SECTION("operator&") {
+    REQUIRE(enum_integer(Language::日本語 & Language::한국어) == (enum_integer(Language::日本語) & enum_integer(Language::한국어)));
+
+  }
+
+  SECTION("operator^") {
+    REQUIRE(enum_integer(Language::日本語 ^ Language::한국어) == (enum_integer(Language::日本語) ^ enum_integer(Language::한국어)));
+  }
+
+  SECTION("operator|=") {
+    Language x5 = Language::日本語;
+    x5 |= Language::한국어;
+    REQUIRE(enum_integer(x5) == (enum_integer(Language::日本語) | enum_integer(Language::한국어)));
+  }
+
+  SECTION("operator&=") {
+    Language x5 = Language::日本語;
+    x5 &= Language::한국어;
+    REQUIRE(enum_integer(x5) == (enum_integer(Language::日本語) & enum_integer(Language::한국어)));
+  }
+
+  SECTION("operator^=") {
+    Language x5 = Language::日本語;
+    x5 ^= Language::한국어;
+    REQUIRE(enum_integer(x5) == (enum_integer(Language::日本語) ^ enum_integer(Language::한국어)));
+  }
+}
+TEST_CASE("type_traits") {
+  REQUIRE_FALSE(is_unscoped_enum_v<Language>);
+}
+
+TEST_CASE("enum_type_name") {
+  REQUIRE(enum_type_name<const Language&>() == "Language");
+}
+
+TEST_CASE("extrema") {
+  SECTION("min") {
+    REQUIRE(magic_enum::customize::enum_range<Language>::min == MAGIC_ENUM_RANGE_MIN);
+    REQUIRE(magic_enum::detail::reflected_min_v<Language, false> == MAGIC_ENUM_RANGE_MIN);
+    REQUIRE(magic_enum::detail::min_v<Language> == 10);
+  }
+
+  SECTION("max") {
+    REQUIRE(magic_enum::customize::enum_range<Language>::max == MAGIC_ENUM_RANGE_MAX);
+    REQUIRE(magic_enum::detail::reflected_max_v<Language, false> == MAGIC_ENUM_RANGE_MAX);
+    REQUIRE(magic_enum::detail::max_v<Language> == 40);
+  }
+}
+
+/* LanguageFlag tests */
+TEST_CASE("flag enum_cast") {
+  SECTION("string") {
+    constexpr auto lang = enum_cast<LanguageFlag>("日本語");
+    REQUIRE(enum_cast<LanguageFlag&>("한국어").value() == LanguageFlag::한국어);
+    REQUIRE(enum_cast<const LanguageFlag>("English").value() == LanguageFlag::English);
+    REQUIRE(lang.value() == LanguageFlag::日本語);
+    REQUIRE(enum_cast<LanguageFlag>("😃").value() == LanguageFlag::😃);
+    REQUIRE_FALSE(enum_cast<LanguageFlag>("None").has_value());
+  }
+
+  SECTION("integer") {
+    constexpr auto lang = enum_cast<LanguageFlag>(1 << 1);
+    REQUIRE(enum_cast<LanguageFlag&>(1 << 2).value() == LanguageFlag::한국어);
+    REQUIRE(enum_cast<const LanguageFlag>(1 << 3).value() == LanguageFlag::English);
+    REQUIRE(lang.value() == LanguageFlag::日本語);
+    REQUIRE(enum_cast<LanguageFlag>(1 << 4).value() == LanguageFlag::😃);
+    REQUIRE_FALSE(enum_cast<LanguageFlag>(0).has_value());
+  }
+}
+
+TEST_CASE("flag enum_index") {
+    constexpr auto lang = enum_index<LanguageFlag>(LanguageFlag::日本語);
+    LanguageFlag korean = LanguageFlag::한국어;
+    REQUIRE(enum_index<LanguageFlag&>(korean).value() == 1);
+    REQUIRE(enum_index<const LanguageFlag>(LanguageFlag::English).value() == 2);
+    REQUIRE(enum_index(LanguageFlag::😃).value() == 3);
+    REQUIRE(lang.value() == 0);
+    REQUIRE_FALSE(enum_index(static_cast<LanguageFlag>(0)).has_value());
+}
+
+TEST_CASE("flag enum_contains") {
+  SECTION("value") {
+    constexpr auto lang = enum_index<LanguageFlag>(LanguageFlag::日本語);
+    LanguageFlag korean = LanguageFlag::한국어;
+    REQUIRE(enum_contains<LanguageFlag&>(korean));
+    REQUIRE(enum_contains<const LanguageFlag>(LanguageFlag::English));
+    REQUIRE(enum_contains(LanguageFlag::😃));
+    REQUIRE(lang);
+    REQUIRE_FALSE(enum_contains(static_cast<LanguageFlag>(0)));
+  }
+
+  SECTION("integer") {
+    constexpr auto lang = enum_contains<LanguageFlag&>(1 << 1);
+    REQUIRE(lang);
+    REQUIRE(enum_contains<const LanguageFlag>(1 << 2));
+    REQUIRE(enum_contains<LanguageFlag>(1 << 3));
+    REQUIRE(enum_contains<LanguageFlag>(1 << 4));
+    REQUIRE_FALSE(enum_contains(static_cast<LanguageFlag>(0)));
+  }
+
+  SECTION("string") {
+    auto lang = std::string{"日本語"};
+    REQUIRE(enum_contains<LanguageFlag&>("한국어"));
+    REQUIRE(enum_contains<LanguageFlag>("English"));
+    REQUIRE(enum_contains<const LanguageFlag>(lang));
+    REQUIRE(enum_contains<LanguageFlag>("😃"));
+    REQUIRE_FALSE(enum_contains<LanguageFlag>("None"));
+  }
+}
+
+
+TEST_CASE("flag enum_value") {
+  constexpr auto lang = enum_value<LanguageFlag>(3);
+  REQUIRE(enum_value<LanguageFlag&>(0) == LanguageFlag::日本語);
+  REQUIRE(enum_value<const LanguageFlag>(1) == LanguageFlag::한국어);
+  REQUIRE(enum_value<LanguageFlag>(2) == LanguageFlag::English);
+  REQUIRE(lang == LanguageFlag::😃);
+}
+
+TEST_CASE("flag enum_values") {
+  constexpr auto& s5 = enum_values<const LanguageFlag>();
+  REQUIRE(s5 == std::array<LanguageFlag, 4>{{LanguageFlag::日本語, LanguageFlag::한국어, LanguageFlag::English, LanguageFlag::😃}});
+}
+
+TEST_CASE("flag enum_count") {
+  constexpr auto s5 = enum_count<LanguageFlag>();
+  REQUIRE(s5 == 4);
+}
+
+TEST_CASE("flag enum_name") {
+  SECTION("automatic storage") {
+    constexpr LanguageFlag lang = LanguageFlag::日本語;
+    constexpr auto lang_name = enum_name(lang);
+    LanguageFlag lk = LanguageFlag::한국어;
+    REQUIRE(enum_name<LanguageFlag&>(lk) == "한국어");
+    REQUIRE(enum_name<const LanguageFlag>(LanguageFlag::English) == "English");
+    REQUIRE(lang_name == "日本語");
+    REQUIRE(enum_name(LanguageFlag::😃) == "😃");
+    REQUIRE(enum_name(static_cast<LanguageFlag>(0)).empty());
+  }
+}
+
+TEST_CASE("flag enum_flags_name") {
+  constexpr LanguageFlag lang = LanguageFlag::日本語;
+  auto lang_name = enum_flags_name(lang);
+  LanguageFlag lk = LanguageFlag::한국어;
+  REQUIRE(enum_flags_name<LanguageFlag&>(lk) == "한국어");
+  REQUIRE(enum_flags_name<const LanguageFlag>(LanguageFlag::English) == "English");
+  REQUIRE(lang_name == "日本語");
+  REQUIRE(enum_flags_name(LanguageFlag::😃) == "😃");
+  REQUIRE(enum_flags_name(static_cast<LanguageFlag>(0)).empty());
+}
+
+TEST_CASE("flag enum_names") {
+  constexpr auto& s5 = enum_names<const LanguageFlag>();
+  REQUIRE(s5 == std::array<std::string_view, 4>{{"日本語", "한국어", "English", "😃"}});
+}
+
+TEST_CASE("flag enum_entries") {
+  constexpr auto& s5 = enum_entries<const LanguageFlag>();
+  REQUIRE(s5 == std::array<std::pair<LanguageFlag, std::string_view>, 4>{{{LanguageFlag::日本語, "日本語"}, {LanguageFlag::한국어, "한국어"}, {LanguageFlag::English, "English"}, {LanguageFlag::😃, "😃"}}});
+}
+
+TEST_CASE("flag ostream_operators") {
+  auto test_ostream = [](auto e, std::string name) {
+    using namespace magic_enum::ostream_operators;
+    std::stringstream ss;
+    ss << e;
+    REQUIRE(ss.str() == name);
+  };
+
+  test_ostream(std::make_optional(LanguageFlag::日本語), "日本語");
+  test_ostream(LanguageFlag::한국어, "한국어");
+  test_ostream(LanguageFlag::English, "English");
+  test_ostream(LanguageFlag::😃, "😃");
+  test_ostream(static_cast<LanguageFlag>(0), "0");
+  test_ostream(std::make_optional(static_cast<LanguageFlag>(0)), "0");
+}
+
+TEST_CASE("flag istream_operators") {
+  auto test_istream = [](const auto e, std::string name) {
+    using namespace magic_enum::istream_operators;
+    std::istringstream ss(name);
+    std::decay_t<decltype(e)> v;
+    ss >> v;
+    REQUIRE(v == e);
+    REQUIRE(ss);
+  };
+
+  test_istream(LanguageFlag::한국어, "한국어");
+  test_istream(LanguageFlag::English, "English");
+  test_istream(LanguageFlag::😃, "😃");
+}
+
+
+TEST_CASE("flag bitwise_operators") {
+  using namespace magic_enum::bitwise_operators;
+  SECTION("operator~") {
+    REQUIRE(enum_integer(~LanguageFlag::日本語) == ~enum_integer(LanguageFlag::日本語));
+  }
+
+  SECTION("operator|") {
+    REQUIRE(enum_integer(LanguageFlag::日本語 | LanguageFlag::한국어) == (enum_integer(LanguageFlag::日本語) | enum_integer(LanguageFlag::한국어)));
+  }
+
+  SECTION("operator&") {
+    REQUIRE(enum_integer(LanguageFlag::日本語 & LanguageFlag::한국어) == (enum_integer(LanguageFlag::日本語) & enum_integer(LanguageFlag::한국어)));
+  }
+
+  SECTION("operator^") {
+    REQUIRE(enum_integer(LanguageFlag::日本語 ^ LanguageFlag::한국어) == (enum_integer(LanguageFlag::日本語) ^ enum_integer(LanguageFlag::한국어)));
+  }
+
+  SECTION("operator|=") {
+    LanguageFlag x5 = LanguageFlag::日本語;
+    x5 |= LanguageFlag::한국어;
+    REQUIRE(enum_integer(x5) == (enum_integer(LanguageFlag::日本語) | enum_integer(LanguageFlag::한국어)));
+  }
+
+  SECTION("operator&=") {
+    LanguageFlag x5 = LanguageFlag::日本語;
+    x5 &= LanguageFlag::한국어;
+    REQUIRE(enum_integer(x5) == (enum_integer(LanguageFlag::日本語) & enum_integer(LanguageFlag::한국어)));
+  }
+
+  SECTION("operator^=") {
+    LanguageFlag x5 = LanguageFlag::日本語;
+    x5 ^= LanguageFlag::한국어;
+    REQUIRE(enum_integer(x5) == (enum_integer(LanguageFlag::日本語) ^ enum_integer(LanguageFlag::한국어)));
+  }
+}