text: // Warning! This file is autogenerated.
  #include <boost/text/normalize_string.hpp>
  #include <boost/text/utility.hpp>
  #include <boost/text/string_utility.hpp>
  
  #include <gtest/gtest.h>
  
  #include <algorithm>
  
  
  
  TEST(normalization, nfkd_018_000)
  {
      // B0A0;B0A0;1102 1161 11AF;B0A0;1102 1161 11AF; 
      // (날; 날; 날; 날; 날; ) HANGUL SYLLABLE NAL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0A0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0A0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0A0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_001)
  {
      // B0A1;B0A1;1102 1161 11B0;B0A1;1102 1161 11B0; 
      // (낡; 낡; 낡; 낡; 낡; ) HANGUL SYLLABLE NALG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0A1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0A1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0A1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_002)
  {
      // B0A2;B0A2;1102 1161 11B1;B0A2;1102 1161 11B1; 
      // (낢; 낢; 낢; 낢; 낢; ) HANGUL SYLLABLE NALM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0A2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0A2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0A2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_003)
  {
      // B0A3;B0A3;1102 1161 11B2;B0A3;1102 1161 11B2; 
      // (낣; 낣; 낣; 낣; 낣; ) HANGUL SYLLABLE NALB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0A3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0A3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0A3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_004)
  {
      // B0A4;B0A4;1102 1161 11B3;B0A4;1102 1161 11B3; 
      // (낤; 낤; 낤; 낤; 낤; ) HANGUL SYLLABLE NALS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0A4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0A4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0A4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_005)
  {
      // B0A5;B0A5;1102 1161 11B4;B0A5;1102 1161 11B4; 
      // (낥; 낥; 낥; 낥; 낥; ) HANGUL SYLLABLE NALT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0A5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0A5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0A5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_006)
  {
      // B0A6;B0A6;1102 1161 11B5;B0A6;1102 1161 11B5; 
      // (낦; 낦; 낦; 낦; 낦; ) HANGUL SYLLABLE NALP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0A6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0A6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0A6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_007)
  {
      // B0A7;B0A7;1102 1161 11B6;B0A7;1102 1161 11B6; 
      // (낧; 낧; 낧; 낧; 낧; ) HANGUL SYLLABLE NALH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0A7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0A7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0A7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_008)
  {
      // B0A8;B0A8;1102 1161 11B7;B0A8;1102 1161 11B7; 
      // (남; 남; 남; 남; 남; ) HANGUL SYLLABLE NAM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0A8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0A8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0A8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_009)
  {
      // B0A9;B0A9;1102 1161 11B8;B0A9;1102 1161 11B8; 
      // (납; 납; 납; 납; 납; ) HANGUL SYLLABLE NAB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0A9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0A9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0A9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_010)
  {
      // B0AA;B0AA;1102 1161 11B9;B0AA;1102 1161 11B9; 
      // (낪; 낪; 낪; 낪; 낪; ) HANGUL SYLLABLE NABS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0AA }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0AA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0AA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_011)
  {
      // B0AB;B0AB;1102 1161 11BA;B0AB;1102 1161 11BA; 
      // (낫; 낫; 낫; 낫; 낫; ) HANGUL SYLLABLE NAS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0AB }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0AB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0AB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_012)
  {
      // B0AC;B0AC;1102 1161 11BB;B0AC;1102 1161 11BB; 
      // (났; 났; 났; 났; 났; ) HANGUL SYLLABLE NASS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0AC }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0AC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0AC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_013)
  {
      // B0AD;B0AD;1102 1161 11BC;B0AD;1102 1161 11BC; 
      // (낭; 낭; 낭; 낭; 낭; ) HANGUL SYLLABLE NANG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0AD }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0AD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0AD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_014)
  {
      // B0AE;B0AE;1102 1161 11BD;B0AE;1102 1161 11BD; 
      // (낮; 낮; 낮; 낮; 낮; ) HANGUL SYLLABLE NAJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0AE }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0AE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0AE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_015)
  {
      // B0AF;B0AF;1102 1161 11BE;B0AF;1102 1161 11BE; 
      // (낯; 낯; 낯; 낯; 낯; ) HANGUL SYLLABLE NAC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0AF }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0AF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0AF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_016)
  {
      // B0B0;B0B0;1102 1161 11BF;B0B0;1102 1161 11BF; 
      // (낰; 낰; 낰; 낰; 낰; ) HANGUL SYLLABLE NAK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0B0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0B0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0B0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_017)
  {
      // B0B1;B0B1;1102 1161 11C0;B0B1;1102 1161 11C0; 
      // (낱; 낱; 낱; 낱; 낱; ) HANGUL SYLLABLE NAT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0B1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0B1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0B1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_018)
  {
      // B0B2;B0B2;1102 1161 11C1;B0B2;1102 1161 11C1; 
      // (낲; 낲; 낲; 낲; 낲; ) HANGUL SYLLABLE NAP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0B2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0B2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0B2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_019)
  {
      // B0B3;B0B3;1102 1161 11C2;B0B3;1102 1161 11C2; 
      // (낳; 낳; 낳; 낳; 낳; ) HANGUL SYLLABLE NAH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0B3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0B3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1161, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0B3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1161, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_020)
  {
      // B0B4;B0B4;1102 1162;B0B4;1102 1162; 
      // (내; 내; 내; 내; 내; ) HANGUL SYLLABLE NAE
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0B4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0B4 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x1162 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0B4 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x1162 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_021)
  {
      // B0B5;B0B5;1102 1162 11A8;B0B5;1102 1162 11A8; 
      // (낵; 낵; 낵; 낵; 낵; ) HANGUL SYLLABLE NAEG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0B5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0B5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0B5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_022)
  {
      // B0B6;B0B6;1102 1162 11A9;B0B6;1102 1162 11A9; 
      // (낶; 낶; 낶; 낶; 낶; ) HANGUL SYLLABLE NAEGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0B6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0B6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0B6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_023)
  {
      // B0B7;B0B7;1102 1162 11AA;B0B7;1102 1162 11AA; 
      // (낷; 낷; 낷; 낷; 낷; ) HANGUL SYLLABLE NAEGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0B7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0B7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0B7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_024)
  {
      // B0B8;B0B8;1102 1162 11AB;B0B8;1102 1162 11AB; 
      // (낸; 낸; 낸; 낸; 낸; ) HANGUL SYLLABLE NAEN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0B8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0B8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0B8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_025)
  {
      // B0B9;B0B9;1102 1162 11AC;B0B9;1102 1162 11AC; 
      // (낹; 낹; 낹; 낹; 낹; ) HANGUL SYLLABLE NAENJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0B9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0B9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0B9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_026)
  {
      // B0BA;B0BA;1102 1162 11AD;B0BA;1102 1162 11AD; 
      // (낺; 낺; 낺; 낺; 낺; ) HANGUL SYLLABLE NAENH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0BA }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0BA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0BA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_027)
  {
      // B0BB;B0BB;1102 1162 11AE;B0BB;1102 1162 11AE; 
      // (낻; 낻; 낻; 낻; 낻; ) HANGUL SYLLABLE NAED
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0BB }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0BB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0BB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_028)
  {
      // B0BC;B0BC;1102 1162 11AF;B0BC;1102 1162 11AF; 
      // (낼; 낼; 낼; 낼; 낼; ) HANGUL SYLLABLE NAEL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0BC }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0BC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0BC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_029)
  {
      // B0BD;B0BD;1102 1162 11B0;B0BD;1102 1162 11B0; 
      // (낽; 낽; 낽; 낽; 낽; ) HANGUL SYLLABLE NAELG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0BD }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0BD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0BD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_030)
  {
      // B0BE;B0BE;1102 1162 11B1;B0BE;1102 1162 11B1; 
      // (낾; 낾; 낾; 낾; 낾; ) HANGUL SYLLABLE NAELM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0BE }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0BE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0BE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_031)
  {
      // B0BF;B0BF;1102 1162 11B2;B0BF;1102 1162 11B2; 
      // (낿; 낿; 낿; 낿; 낿; ) HANGUL SYLLABLE NAELB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0BF }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0BF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0BF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_032)
  {
      // B0C0;B0C0;1102 1162 11B3;B0C0;1102 1162 11B3; 
      // (냀; 냀; 냀; 냀; 냀; ) HANGUL SYLLABLE NAELS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0C0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0C0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0C0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_033)
  {
      // B0C1;B0C1;1102 1162 11B4;B0C1;1102 1162 11B4; 
      // (냁; 냁; 냁; 냁; 냁; ) HANGUL SYLLABLE NAELT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0C1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0C1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0C1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_034)
  {
      // B0C2;B0C2;1102 1162 11B5;B0C2;1102 1162 11B5; 
      // (냂; 냂; 냂; 냂; 냂; ) HANGUL SYLLABLE NAELP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0C2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0C2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0C2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_035)
  {
      // B0C3;B0C3;1102 1162 11B6;B0C3;1102 1162 11B6; 
      // (냃; 냃; 냃; 냃; 냃; ) HANGUL SYLLABLE NAELH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0C3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0C3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0C3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_036)
  {
      // B0C4;B0C4;1102 1162 11B7;B0C4;1102 1162 11B7; 
      // (냄; 냄; 냄; 냄; 냄; ) HANGUL SYLLABLE NAEM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0C4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0C4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0C4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_037)
  {
      // B0C5;B0C5;1102 1162 11B8;B0C5;1102 1162 11B8; 
      // (냅; 냅; 냅; 냅; 냅; ) HANGUL SYLLABLE NAEB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0C5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0C5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0C5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_038)
  {
      // B0C6;B0C6;1102 1162 11B9;B0C6;1102 1162 11B9; 
      // (냆; 냆; 냆; 냆; 냆; ) HANGUL SYLLABLE NAEBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0C6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0C6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0C6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_039)
  {
      // B0C7;B0C7;1102 1162 11BA;B0C7;1102 1162 11BA; 
      // (냇; 냇; 냇; 냇; 냇; ) HANGUL SYLLABLE NAES
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0C7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0C7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0C7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_040)
  {
      // B0C8;B0C8;1102 1162 11BB;B0C8;1102 1162 11BB; 
      // (냈; 냈; 냈; 냈; 냈; ) HANGUL SYLLABLE NAESS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0C8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0C8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0C8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_041)
  {
      // B0C9;B0C9;1102 1162 11BC;B0C9;1102 1162 11BC; 
      // (냉; 냉; 냉; 냉; 냉; ) HANGUL SYLLABLE NAENG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0C9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0C9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0C9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_042)
  {
      // B0CA;B0CA;1102 1162 11BD;B0CA;1102 1162 11BD; 
      // (냊; 냊; 냊; 냊; 냊; ) HANGUL SYLLABLE NAEJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0CA }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0CA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0CA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_043)
  {
      // B0CB;B0CB;1102 1162 11BE;B0CB;1102 1162 11BE; 
      // (냋; 냋; 냋; 냋; 냋; ) HANGUL SYLLABLE NAEC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0CB }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0CB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0CB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_044)
  {
      // B0CC;B0CC;1102 1162 11BF;B0CC;1102 1162 11BF; 
      // (냌; 냌; 냌; 냌; 냌; ) HANGUL SYLLABLE NAEK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0CC }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0CC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0CC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_045)
  {
      // B0CD;B0CD;1102 1162 11C0;B0CD;1102 1162 11C0; 
      // (냍; 냍; 냍; 냍; 냍; ) HANGUL SYLLABLE NAET
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0CD }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0CD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0CD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_046)
  {
      // B0CE;B0CE;1102 1162 11C1;B0CE;1102 1162 11C1; 
      // (냎; 냎; 냎; 냎; 냎; ) HANGUL SYLLABLE NAEP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0CE }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0CE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0CE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_047)
  {
      // B0CF;B0CF;1102 1162 11C2;B0CF;1102 1162 11C2; 
      // (냏; 냏; 냏; 냏; 냏; ) HANGUL SYLLABLE NAEH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0CF }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0CF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1162, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0CF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1162, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_048)
  {
      // B0D0;B0D0;1102 1163;B0D0;1102 1163; 
      // (냐; 냐; 냐; 냐; 냐; ) HANGUL SYLLABLE NYA
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0D0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0D0 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x1163 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0D0 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x1163 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_049)
  {
      // B0D1;B0D1;1102 1163 11A8;B0D1;1102 1163 11A8; 
      // (냑; 냑; 냑; 냑; 냑; ) HANGUL SYLLABLE NYAG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0D1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0D1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0D1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_050)
  {
      // B0D2;B0D2;1102 1163 11A9;B0D2;1102 1163 11A9; 
      // (냒; 냒; 냒; 냒; 냒; ) HANGUL SYLLABLE NYAGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0D2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0D2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0D2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_051)
  {
      // B0D3;B0D3;1102 1163 11AA;B0D3;1102 1163 11AA; 
      // (냓; 냓; 냓; 냓; 냓; ) HANGUL SYLLABLE NYAGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0D3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0D3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0D3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_052)
  {
      // B0D4;B0D4;1102 1163 11AB;B0D4;1102 1163 11AB; 
      // (냔; 냔; 냔; 냔; 냔; ) HANGUL SYLLABLE NYAN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0D4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0D4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0D4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_053)
  {
      // B0D5;B0D5;1102 1163 11AC;B0D5;1102 1163 11AC; 
      // (냕; 냕; 냕; 냕; 냕; ) HANGUL SYLLABLE NYANJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0D5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0D5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0D5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_054)
  {
      // B0D6;B0D6;1102 1163 11AD;B0D6;1102 1163 11AD; 
      // (냖; 냖; 냖; 냖; 냖; ) HANGUL SYLLABLE NYANH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0D6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0D6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0D6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_055)
  {
      // B0D7;B0D7;1102 1163 11AE;B0D7;1102 1163 11AE; 
      // (냗; 냗; 냗; 냗; 냗; ) HANGUL SYLLABLE NYAD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0D7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0D7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0D7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_056)
  {
      // B0D8;B0D8;1102 1163 11AF;B0D8;1102 1163 11AF; 
      // (냘; 냘; 냘; 냘; 냘; ) HANGUL SYLLABLE NYAL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0D8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0D8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0D8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_057)
  {
      // B0D9;B0D9;1102 1163 11B0;B0D9;1102 1163 11B0; 
      // (냙; 냙; 냙; 냙; 냙; ) HANGUL SYLLABLE NYALG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0D9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0D9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0D9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_058)
  {
      // B0DA;B0DA;1102 1163 11B1;B0DA;1102 1163 11B1; 
      // (냚; 냚; 냚; 냚; 냚; ) HANGUL SYLLABLE NYALM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0DA }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0DA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0DA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_059)
  {
      // B0DB;B0DB;1102 1163 11B2;B0DB;1102 1163 11B2; 
      // (냛; 냛; 냛; 냛; 냛; ) HANGUL SYLLABLE NYALB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0DB }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0DB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0DB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_060)
  {
      // B0DC;B0DC;1102 1163 11B3;B0DC;1102 1163 11B3; 
      // (냜; 냜; 냜; 냜; 냜; ) HANGUL SYLLABLE NYALS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0DC }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0DC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0DC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_061)
  {
      // B0DD;B0DD;1102 1163 11B4;B0DD;1102 1163 11B4; 
      // (냝; 냝; 냝; 냝; 냝; ) HANGUL SYLLABLE NYALT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0DD }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0DD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0DD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_062)
  {
      // B0DE;B0DE;1102 1163 11B5;B0DE;1102 1163 11B5; 
      // (냞; 냞; 냞; 냞; 냞; ) HANGUL SYLLABLE NYALP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0DE }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0DE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0DE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_063)
  {
      // B0DF;B0DF;1102 1163 11B6;B0DF;1102 1163 11B6; 
      // (냟; 냟; 냟; 냟; 냟; ) HANGUL SYLLABLE NYALH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0DF }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0DF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0DF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_064)
  {
      // B0E0;B0E0;1102 1163 11B7;B0E0;1102 1163 11B7; 
      // (냠; 냠; 냠; 냠; 냠; ) HANGUL SYLLABLE NYAM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0E0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0E0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0E0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_065)
  {
      // B0E1;B0E1;1102 1163 11B8;B0E1;1102 1163 11B8; 
      // (냡; 냡; 냡; 냡; 냡; ) HANGUL SYLLABLE NYAB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0E1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0E1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0E1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_066)
  {
      // B0E2;B0E2;1102 1163 11B9;B0E2;1102 1163 11B9; 
      // (냢; 냢; 냢; 냢; 냢; ) HANGUL SYLLABLE NYABS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0E2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0E2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0E2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_067)
  {
      // B0E3;B0E3;1102 1163 11BA;B0E3;1102 1163 11BA; 
      // (냣; 냣; 냣; 냣; 냣; ) HANGUL SYLLABLE NYAS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0E3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0E3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0E3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_068)
  {
      // B0E4;B0E4;1102 1163 11BB;B0E4;1102 1163 11BB; 
      // (냤; 냤; 냤; 냤; 냤; ) HANGUL SYLLABLE NYASS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0E4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0E4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0E4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_069)
  {
      // B0E5;B0E5;1102 1163 11BC;B0E5;1102 1163 11BC; 
      // (냥; 냥; 냥; 냥; 냥; ) HANGUL SYLLABLE NYANG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0E5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0E5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0E5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_070)
  {
      // B0E6;B0E6;1102 1163 11BD;B0E6;1102 1163 11BD; 
      // (냦; 냦; 냦; 냦; 냦; ) HANGUL SYLLABLE NYAJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0E6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0E6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0E6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_071)
  {
      // B0E7;B0E7;1102 1163 11BE;B0E7;1102 1163 11BE; 
      // (냧; 냧; 냧; 냧; 냧; ) HANGUL SYLLABLE NYAC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0E7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0E7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0E7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_072)
  {
      // B0E8;B0E8;1102 1163 11BF;B0E8;1102 1163 11BF; 
      // (냨; 냨; 냨; 냨; 냨; ) HANGUL SYLLABLE NYAK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0E8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0E8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0E8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_073)
  {
      // B0E9;B0E9;1102 1163 11C0;B0E9;1102 1163 11C0; 
      // (냩; 냩; 냩; 냩; 냩; ) HANGUL SYLLABLE NYAT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0E9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0E9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0E9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_074)
  {
      // B0EA;B0EA;1102 1163 11C1;B0EA;1102 1163 11C1; 
      // (냪; 냪; 냪; 냪; 냪; ) HANGUL SYLLABLE NYAP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0EA }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0EA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0EA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_075)
  {
      // B0EB;B0EB;1102 1163 11C2;B0EB;1102 1163 11C2; 
      // (냫; 냫; 냫; 냫; 냫; ) HANGUL SYLLABLE NYAH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0EB }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0EB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1163, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0EB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1163, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_076)
  {
      // B0EC;B0EC;1102 1164;B0EC;1102 1164; 
      // (냬; 냬; 냬; 냬; 냬; ) HANGUL SYLLABLE NYAE
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0EC }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0EC }};
          std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x1164 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0EC }};
          std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x1164 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_077)
  {
      // B0ED;B0ED;1102 1164 11A8;B0ED;1102 1164 11A8; 
      // (냭; 냭; 냭; 냭; 냭; ) HANGUL SYLLABLE NYAEG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0ED }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0ED }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0ED }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_078)
  {
      // B0EE;B0EE;1102 1164 11A9;B0EE;1102 1164 11A9; 
      // (냮; 냮; 냮; 냮; 냮; ) HANGUL SYLLABLE NYAEGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0EE }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0EE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0EE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_079)
  {
      // B0EF;B0EF;1102 1164 11AA;B0EF;1102 1164 11AA; 
      // (냯; 냯; 냯; 냯; 냯; ) HANGUL SYLLABLE NYAEGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0EF }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0EF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0EF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_080)
  {
      // B0F0;B0F0;1102 1164 11AB;B0F0;1102 1164 11AB; 
      // (냰; 냰; 냰; 냰; 냰; ) HANGUL SYLLABLE NYAEN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0F0 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0F0 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0F0 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_081)
  {
      // B0F1;B0F1;1102 1164 11AC;B0F1;1102 1164 11AC; 
      // (냱; 냱; 냱; 냱; 냱; ) HANGUL SYLLABLE NYAENJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0F1 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0F1 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0F1 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_082)
  {
      // B0F2;B0F2;1102 1164 11AD;B0F2;1102 1164 11AD; 
      // (냲; 냲; 냲; 냲; 냲; ) HANGUL SYLLABLE NYAENH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0F2 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0F2 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0F2 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_083)
  {
      // B0F3;B0F3;1102 1164 11AE;B0F3;1102 1164 11AE; 
      // (냳; 냳; 냳; 냳; 냳; ) HANGUL SYLLABLE NYAED
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0F3 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0F3 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0F3 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_084)
  {
      // B0F4;B0F4;1102 1164 11AF;B0F4;1102 1164 11AF; 
      // (냴; 냴; 냴; 냴; 냴; ) HANGUL SYLLABLE NYAEL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0F4 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0F4 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0F4 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_085)
  {
      // B0F5;B0F5;1102 1164 11B0;B0F5;1102 1164 11B0; 
      // (냵; 냵; 냵; 냵; 냵; ) HANGUL SYLLABLE NYAELG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0F5 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0F5 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0F5 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_086)
  {
      // B0F6;B0F6;1102 1164 11B1;B0F6;1102 1164 11B1; 
      // (냶; 냶; 냶; 냶; 냶; ) HANGUL SYLLABLE NYAELM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0F6 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0F6 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0F6 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_087)
  {
      // B0F7;B0F7;1102 1164 11B2;B0F7;1102 1164 11B2; 
      // (냷; 냷; 냷; 냷; 냷; ) HANGUL SYLLABLE NYAELB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0F7 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0F7 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0F7 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_088)
  {
      // B0F8;B0F8;1102 1164 11B3;B0F8;1102 1164 11B3; 
      // (냸; 냸; 냸; 냸; 냸; ) HANGUL SYLLABLE NYAELS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0F8 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0F8 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0F8 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_089)
  {
      // B0F9;B0F9;1102 1164 11B4;B0F9;1102 1164 11B4; 
      // (냹; 냹; 냹; 냹; 냹; ) HANGUL SYLLABLE NYAELT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0F9 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0F9 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0F9 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_090)
  {
      // B0FA;B0FA;1102 1164 11B5;B0FA;1102 1164 11B5; 
      // (냺; 냺; 냺; 냺; 냺; ) HANGUL SYLLABLE NYAELP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0FA }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0FA }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0FA }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_091)
  {
      // B0FB;B0FB;1102 1164 11B6;B0FB;1102 1164 11B6; 
      // (냻; 냻; 냻; 냻; 냻; ) HANGUL SYLLABLE NYAELH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0FB }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0FB }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0FB }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_092)
  {
      // B0FC;B0FC;1102 1164 11B7;B0FC;1102 1164 11B7; 
      // (냼; 냼; 냼; 냼; 냼; ) HANGUL SYLLABLE NYAEM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0FC }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0FC }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0FC }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_093)
  {
      // B0FD;B0FD;1102 1164 11B8;B0FD;1102 1164 11B8; 
      // (냽; 냽; 냽; 냽; 냽; ) HANGUL SYLLABLE NYAEB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0FD }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0FD }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0FD }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_094)
  {
      // B0FE;B0FE;1102 1164 11B9;B0FE;1102 1164 11B9; 
      // (냾; 냾; 냾; 냾; 냾; ) HANGUL SYLLABLE NYAEBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0FE }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0FE }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0FE }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_095)
  {
      // B0FF;B0FF;1102 1164 11BA;B0FF;1102 1164 11BA; 
      // (냿; 냿; 냿; 냿; 냿; ) HANGUL SYLLABLE NYAES
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB0FF }};
          std::array<uint32_t, 1> const c2 = {{ 0xB0FF }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB0FF }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_096)
  {
      // B100;B100;1102 1164 11BB;B100;1102 1164 11BB; 
      // (넀; 넀; 넀; 넀; 넀; ) HANGUL SYLLABLE NYAESS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB100 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB100 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB100 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_097)
  {
      // B101;B101;1102 1164 11BC;B101;1102 1164 11BC; 
      // (넁; 넁; 넁; 넁; 넁; ) HANGUL SYLLABLE NYAENG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB101 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB101 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB101 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_098)
  {
      // B102;B102;1102 1164 11BD;B102;1102 1164 11BD; 
      // (넂; 넂; 넂; 넂; 넂; ) HANGUL SYLLABLE NYAEJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB102 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB102 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB102 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_099)
  {
      // B103;B103;1102 1164 11BE;B103;1102 1164 11BE; 
      // (넃; 넃; 넃; 넃; 넃; ) HANGUL SYLLABLE NYAEC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB103 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB103 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB103 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_100)
  {
      // B104;B104;1102 1164 11BF;B104;1102 1164 11BF; 
      // (넄; 넄; 넄; 넄; 넄; ) HANGUL SYLLABLE NYAEK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB104 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB104 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB104 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_101)
  {
      // B105;B105;1102 1164 11C0;B105;1102 1164 11C0; 
      // (넅; 넅; 넅; 넅; 넅; ) HANGUL SYLLABLE NYAET
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB105 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB105 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB105 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_102)
  {
      // B106;B106;1102 1164 11C1;B106;1102 1164 11C1; 
      // (넆; 넆; 넆; 넆; 넆; ) HANGUL SYLLABLE NYAEP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB106 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB106 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB106 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_103)
  {
      // B107;B107;1102 1164 11C2;B107;1102 1164 11C2; 
      // (넇; 넇; 넇; 넇; 넇; ) HANGUL SYLLABLE NYAEH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB107 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB107 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1164, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB107 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1164, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_104)
  {
      // B108;B108;1102 1165;B108;1102 1165; 
      // (너; 너; 너; 너; 너; ) HANGUL SYLLABLE NEO
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB108 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB108 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x1165 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB108 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x1165 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_105)
  {
      // B109;B109;1102 1165 11A8;B109;1102 1165 11A8; 
      // (넉; 넉; 넉; 넉; 넉; ) HANGUL SYLLABLE NEOG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB109 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB109 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB109 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_106)
  {
      // B10A;B10A;1102 1165 11A9;B10A;1102 1165 11A9; 
      // (넊; 넊; 넊; 넊; 넊; ) HANGUL SYLLABLE NEOGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB10A }};
          std::array<uint32_t, 1> const c2 = {{ 0xB10A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB10A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_107)
  {
      // B10B;B10B;1102 1165 11AA;B10B;1102 1165 11AA; 
      // (넋; 넋; 넋; 넋; 넋; ) HANGUL SYLLABLE NEOGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB10B }};
          std::array<uint32_t, 1> const c2 = {{ 0xB10B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB10B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_108)
  {
      // B10C;B10C;1102 1165 11AB;B10C;1102 1165 11AB; 
      // (넌; 넌; 넌; 넌; 넌; ) HANGUL SYLLABLE NEON
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB10C }};
          std::array<uint32_t, 1> const c2 = {{ 0xB10C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB10C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_109)
  {
      // B10D;B10D;1102 1165 11AC;B10D;1102 1165 11AC; 
      // (넍; 넍; 넍; 넍; 넍; ) HANGUL SYLLABLE NEONJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB10D }};
          std::array<uint32_t, 1> const c2 = {{ 0xB10D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB10D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_110)
  {
      // B10E;B10E;1102 1165 11AD;B10E;1102 1165 11AD; 
      // (넎; 넎; 넎; 넎; 넎; ) HANGUL SYLLABLE NEONH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB10E }};
          std::array<uint32_t, 1> const c2 = {{ 0xB10E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB10E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_111)
  {
      // B10F;B10F;1102 1165 11AE;B10F;1102 1165 11AE; 
      // (넏; 넏; 넏; 넏; 넏; ) HANGUL SYLLABLE NEOD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB10F }};
          std::array<uint32_t, 1> const c2 = {{ 0xB10F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB10F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_112)
  {
      // B110;B110;1102 1165 11AF;B110;1102 1165 11AF; 
      // (널; 널; 널; 널; 널; ) HANGUL SYLLABLE NEOL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB110 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB110 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB110 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_113)
  {
      // B111;B111;1102 1165 11B0;B111;1102 1165 11B0; 
      // (넑; 넑; 넑; 넑; 넑; ) HANGUL SYLLABLE NEOLG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB111 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB111 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB111 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_114)
  {
      // B112;B112;1102 1165 11B1;B112;1102 1165 11B1; 
      // (넒; 넒; 넒; 넒; 넒; ) HANGUL SYLLABLE NEOLM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB112 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB112 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB112 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_115)
  {
      // B113;B113;1102 1165 11B2;B113;1102 1165 11B2; 
      // (넓; 넓; 넓; 넓; 넓; ) HANGUL SYLLABLE NEOLB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB113 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB113 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB113 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_116)
  {
      // B114;B114;1102 1165 11B3;B114;1102 1165 11B3; 
      // (넔; 넔; 넔; 넔; 넔; ) HANGUL SYLLABLE NEOLS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB114 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB114 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB114 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_117)
  {
      // B115;B115;1102 1165 11B4;B115;1102 1165 11B4; 
      // (넕; 넕; 넕; 넕; 넕; ) HANGUL SYLLABLE NEOLT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB115 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB115 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB115 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_118)
  {
      // B116;B116;1102 1165 11B5;B116;1102 1165 11B5; 
      // (넖; 넖; 넖; 넖; 넖; ) HANGUL SYLLABLE NEOLP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB116 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB116 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB116 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_119)
  {
      // B117;B117;1102 1165 11B6;B117;1102 1165 11B6; 
      // (넗; 넗; 넗; 넗; 넗; ) HANGUL SYLLABLE NEOLH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB117 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB117 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB117 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_120)
  {
      // B118;B118;1102 1165 11B7;B118;1102 1165 11B7; 
      // (넘; 넘; 넘; 넘; 넘; ) HANGUL SYLLABLE NEOM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB118 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB118 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB118 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_121)
  {
      // B119;B119;1102 1165 11B8;B119;1102 1165 11B8; 
      // (넙; 넙; 넙; 넙; 넙; ) HANGUL SYLLABLE NEOB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB119 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB119 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB119 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_122)
  {
      // B11A;B11A;1102 1165 11B9;B11A;1102 1165 11B9; 
      // (넚; 넚; 넚; 넚; 넚; ) HANGUL SYLLABLE NEOBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB11A }};
          std::array<uint32_t, 1> const c2 = {{ 0xB11A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB11A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_123)
  {
      // B11B;B11B;1102 1165 11BA;B11B;1102 1165 11BA; 
      // (넛; 넛; 넛; 넛; 넛; ) HANGUL SYLLABLE NEOS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB11B }};
          std::array<uint32_t, 1> const c2 = {{ 0xB11B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB11B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_124)
  {
      // B11C;B11C;1102 1165 11BB;B11C;1102 1165 11BB; 
      // (넜; 넜; 넜; 넜; 넜; ) HANGUL SYLLABLE NEOSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB11C }};
          std::array<uint32_t, 1> const c2 = {{ 0xB11C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB11C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_125)
  {
      // B11D;B11D;1102 1165 11BC;B11D;1102 1165 11BC; 
      // (넝; 넝; 넝; 넝; 넝; ) HANGUL SYLLABLE NEONG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB11D }};
          std::array<uint32_t, 1> const c2 = {{ 0xB11D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB11D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_126)
  {
      // B11E;B11E;1102 1165 11BD;B11E;1102 1165 11BD; 
      // (넞; 넞; 넞; 넞; 넞; ) HANGUL SYLLABLE NEOJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB11E }};
          std::array<uint32_t, 1> const c2 = {{ 0xB11E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB11E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_127)
  {
      // B11F;B11F;1102 1165 11BE;B11F;1102 1165 11BE; 
      // (넟; 넟; 넟; 넟; 넟; ) HANGUL SYLLABLE NEOC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB11F }};
          std::array<uint32_t, 1> const c2 = {{ 0xB11F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB11F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_128)
  {
      // B120;B120;1102 1165 11BF;B120;1102 1165 11BF; 
      // (넠; 넠; 넠; 넠; 넠; ) HANGUL SYLLABLE NEOK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB120 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB120 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB120 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_129)
  {
      // B121;B121;1102 1165 11C0;B121;1102 1165 11C0; 
      // (넡; 넡; 넡; 넡; 넡; ) HANGUL SYLLABLE NEOT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB121 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB121 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB121 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_130)
  {
      // B122;B122;1102 1165 11C1;B122;1102 1165 11C1; 
      // (넢; 넢; 넢; 넢; 넢; ) HANGUL SYLLABLE NEOP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB122 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB122 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB122 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_131)
  {
      // B123;B123;1102 1165 11C2;B123;1102 1165 11C2; 
      // (넣; 넣; 넣; 넣; 넣; ) HANGUL SYLLABLE NEOH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB123 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB123 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1165, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB123 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1165, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_132)
  {
      // B124;B124;1102 1166;B124;1102 1166; 
      // (네; 네; 네; 네; 네; ) HANGUL SYLLABLE NE
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB124 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB124 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x1166 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB124 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x1166 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_133)
  {
      // B125;B125;1102 1166 11A8;B125;1102 1166 11A8; 
      // (넥; 넥; 넥; 넥; 넥; ) HANGUL SYLLABLE NEG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB125 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB125 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB125 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_134)
  {
      // B126;B126;1102 1166 11A9;B126;1102 1166 11A9; 
      // (넦; 넦; 넦; 넦; 넦; ) HANGUL SYLLABLE NEGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB126 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB126 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB126 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_135)
  {
      // B127;B127;1102 1166 11AA;B127;1102 1166 11AA; 
      // (넧; 넧; 넧; 넧; 넧; ) HANGUL SYLLABLE NEGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB127 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB127 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB127 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_136)
  {
      // B128;B128;1102 1166 11AB;B128;1102 1166 11AB; 
      // (넨; 넨; 넨; 넨; 넨; ) HANGUL SYLLABLE NEN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB128 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB128 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB128 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_137)
  {
      // B129;B129;1102 1166 11AC;B129;1102 1166 11AC; 
      // (넩; 넩; 넩; 넩; 넩; ) HANGUL SYLLABLE NENJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB129 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB129 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB129 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_138)
  {
      // B12A;B12A;1102 1166 11AD;B12A;1102 1166 11AD; 
      // (넪; 넪; 넪; 넪; 넪; ) HANGUL SYLLABLE NENH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB12A }};
          std::array<uint32_t, 1> const c2 = {{ 0xB12A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB12A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_139)
  {
      // B12B;B12B;1102 1166 11AE;B12B;1102 1166 11AE; 
      // (넫; 넫; 넫; 넫; 넫; ) HANGUL SYLLABLE NED
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB12B }};
          std::array<uint32_t, 1> const c2 = {{ 0xB12B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB12B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_140)
  {
      // B12C;B12C;1102 1166 11AF;B12C;1102 1166 11AF; 
      // (넬; 넬; 넬; 넬; 넬; ) HANGUL SYLLABLE NEL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB12C }};
          std::array<uint32_t, 1> const c2 = {{ 0xB12C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB12C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_141)
  {
      // B12D;B12D;1102 1166 11B0;B12D;1102 1166 11B0; 
      // (넭; 넭; 넭; 넭; 넭; ) HANGUL SYLLABLE NELG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB12D }};
          std::array<uint32_t, 1> const c2 = {{ 0xB12D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB12D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_142)
  {
      // B12E;B12E;1102 1166 11B1;B12E;1102 1166 11B1; 
      // (넮; 넮; 넮; 넮; 넮; ) HANGUL SYLLABLE NELM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB12E }};
          std::array<uint32_t, 1> const c2 = {{ 0xB12E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB12E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_143)
  {
      // B12F;B12F;1102 1166 11B2;B12F;1102 1166 11B2; 
      // (넯; 넯; 넯; 넯; 넯; ) HANGUL SYLLABLE NELB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB12F }};
          std::array<uint32_t, 1> const c2 = {{ 0xB12F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB12F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_144)
  {
      // B130;B130;1102 1166 11B3;B130;1102 1166 11B3; 
      // (넰; 넰; 넰; 넰; 넰; ) HANGUL SYLLABLE NELS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB130 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB130 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB130 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_145)
  {
      // B131;B131;1102 1166 11B4;B131;1102 1166 11B4; 
      // (넱; 넱; 넱; 넱; 넱; ) HANGUL SYLLABLE NELT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB131 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB131 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB131 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_146)
  {
      // B132;B132;1102 1166 11B5;B132;1102 1166 11B5; 
      // (넲; 넲; 넲; 넲; 넲; ) HANGUL SYLLABLE NELP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB132 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB132 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB132 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_147)
  {
      // B133;B133;1102 1166 11B6;B133;1102 1166 11B6; 
      // (넳; 넳; 넳; 넳; 넳; ) HANGUL SYLLABLE NELH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB133 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB133 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB133 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_148)
  {
      // B134;B134;1102 1166 11B7;B134;1102 1166 11B7; 
      // (넴; 넴; 넴; 넴; 넴; ) HANGUL SYLLABLE NEM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB134 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB134 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB134 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_149)
  {
      // B135;B135;1102 1166 11B8;B135;1102 1166 11B8; 
      // (넵; 넵; 넵; 넵; 넵; ) HANGUL SYLLABLE NEB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB135 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB135 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB135 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_150)
  {
      // B136;B136;1102 1166 11B9;B136;1102 1166 11B9; 
      // (넶; 넶; 넶; 넶; 넶; ) HANGUL SYLLABLE NEBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB136 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB136 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB136 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_151)
  {
      // B137;B137;1102 1166 11BA;B137;1102 1166 11BA; 
      // (넷; 넷; 넷; 넷; 넷; ) HANGUL SYLLABLE NES
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB137 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB137 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB137 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_152)
  {
      // B138;B138;1102 1166 11BB;B138;1102 1166 11BB; 
      // (넸; 넸; 넸; 넸; 넸; ) HANGUL SYLLABLE NESS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB138 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB138 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB138 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_153)
  {
      // B139;B139;1102 1166 11BC;B139;1102 1166 11BC; 
      // (넹; 넹; 넹; 넹; 넹; ) HANGUL SYLLABLE NENG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB139 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB139 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB139 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_154)
  {
      // B13A;B13A;1102 1166 11BD;B13A;1102 1166 11BD; 
      // (넺; 넺; 넺; 넺; 넺; ) HANGUL SYLLABLE NEJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB13A }};
          std::array<uint32_t, 1> const c2 = {{ 0xB13A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB13A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_155)
  {
      // B13B;B13B;1102 1166 11BE;B13B;1102 1166 11BE; 
      // (넻; 넻; 넻; 넻; 넻; ) HANGUL SYLLABLE NEC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB13B }};
          std::array<uint32_t, 1> const c2 = {{ 0xB13B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB13B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_156)
  {
      // B13C;B13C;1102 1166 11BF;B13C;1102 1166 11BF; 
      // (넼; 넼; 넼; 넼; 넼; ) HANGUL SYLLABLE NEK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB13C }};
          std::array<uint32_t, 1> const c2 = {{ 0xB13C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB13C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_157)
  {
      // B13D;B13D;1102 1166 11C0;B13D;1102 1166 11C0; 
      // (넽; 넽; 넽; 넽; 넽; ) HANGUL SYLLABLE NET
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB13D }};
          std::array<uint32_t, 1> const c2 = {{ 0xB13D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB13D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_158)
  {
      // B13E;B13E;1102 1166 11C1;B13E;1102 1166 11C1; 
      // (넾; 넾; 넾; 넾; 넾; ) HANGUL SYLLABLE NEP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB13E }};
          std::array<uint32_t, 1> const c2 = {{ 0xB13E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB13E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_159)
  {
      // B13F;B13F;1102 1166 11C2;B13F;1102 1166 11C2; 
      // (넿; 넿; 넿; 넿; 넿; ) HANGUL SYLLABLE NEH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB13F }};
          std::array<uint32_t, 1> const c2 = {{ 0xB13F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1166, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB13F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1166, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_160)
  {
      // B140;B140;1102 1167;B140;1102 1167; 
      // (녀; 녀; 녀; 녀; 녀; ) HANGUL SYLLABLE NYEO
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB140 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB140 }};
          std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x1167 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB140 }};
          std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x1167 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_161)
  {
      // B141;B141;1102 1167 11A8;B141;1102 1167 11A8; 
      // (녁; 녁; 녁; 녁; 녁; ) HANGUL SYLLABLE NYEOG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB141 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB141 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB141 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_162)
  {
      // B142;B142;1102 1167 11A9;B142;1102 1167 11A9; 
      // (녂; 녂; 녂; 녂; 녂; ) HANGUL SYLLABLE NYEOGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB142 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB142 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB142 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_163)
  {
      // B143;B143;1102 1167 11AA;B143;1102 1167 11AA; 
      // (녃; 녃; 녃; 녃; 녃; ) HANGUL SYLLABLE NYEOGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB143 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB143 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB143 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_164)
  {
      // B144;B144;1102 1167 11AB;B144;1102 1167 11AB; 
      // (년; 년; 년; 년; 년; ) HANGUL SYLLABLE NYEON
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB144 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB144 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB144 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_165)
  {
      // B145;B145;1102 1167 11AC;B145;1102 1167 11AC; 
      // (녅; 녅; 녅; 녅; 녅; ) HANGUL SYLLABLE NYEONJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB145 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB145 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB145 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_166)
  {
      // B146;B146;1102 1167 11AD;B146;1102 1167 11AD; 
      // (녆; 녆; 녆; 녆; 녆; ) HANGUL SYLLABLE NYEONH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB146 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB146 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB146 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_167)
  {
      // B147;B147;1102 1167 11AE;B147;1102 1167 11AE; 
      // (녇; 녇; 녇; 녇; 녇; ) HANGUL SYLLABLE NYEOD
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB147 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB147 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB147 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_168)
  {
      // B148;B148;1102 1167 11AF;B148;1102 1167 11AF; 
      // (녈; 녈; 녈; 녈; 녈; ) HANGUL SYLLABLE NYEOL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB148 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB148 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB148 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_169)
  {
      // B149;B149;1102 1167 11B0;B149;1102 1167 11B0; 
      // (녉; 녉; 녉; 녉; 녉; ) HANGUL SYLLABLE NYEOLG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB149 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB149 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB149 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_170)
  {
      // B14A;B14A;1102 1167 11B1;B14A;1102 1167 11B1; 
      // (녊; 녊; 녊; 녊; 녊; ) HANGUL SYLLABLE NYEOLM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB14A }};
          std::array<uint32_t, 1> const c2 = {{ 0xB14A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB14A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_171)
  {
      // B14B;B14B;1102 1167 11B2;B14B;1102 1167 11B2; 
      // (녋; 녋; 녋; 녋; 녋; ) HANGUL SYLLABLE NYEOLB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB14B }};
          std::array<uint32_t, 1> const c2 = {{ 0xB14B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB14B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_172)
  {
      // B14C;B14C;1102 1167 11B3;B14C;1102 1167 11B3; 
      // (녌; 녌; 녌; 녌; 녌; ) HANGUL SYLLABLE NYEOLS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB14C }};
          std::array<uint32_t, 1> const c2 = {{ 0xB14C }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11B3 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB14C }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11B3 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_173)
  {
      // B14D;B14D;1102 1167 11B4;B14D;1102 1167 11B4; 
      // (녍; 녍; 녍; 녍; 녍; ) HANGUL SYLLABLE NYEOLT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB14D }};
          std::array<uint32_t, 1> const c2 = {{ 0xB14D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11B4 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB14D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11B4 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_174)
  {
      // B14E;B14E;1102 1167 11B5;B14E;1102 1167 11B5; 
      // (녎; 녎; 녎; 녎; 녎; ) HANGUL SYLLABLE NYEOLP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB14E }};
          std::array<uint32_t, 1> const c2 = {{ 0xB14E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11B5 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB14E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11B5 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_175)
  {
      // B14F;B14F;1102 1167 11B6;B14F;1102 1167 11B6; 
      // (녏; 녏; 녏; 녏; 녏; ) HANGUL SYLLABLE NYEOLH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB14F }};
          std::array<uint32_t, 1> const c2 = {{ 0xB14F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11B6 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB14F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11B6 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_176)
  {
      // B150;B150;1102 1167 11B7;B150;1102 1167 11B7; 
      // (념; 념; 념; 념; 념; ) HANGUL SYLLABLE NYEOM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB150 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB150 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11B7 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB150 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11B7 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_177)
  {
      // B151;B151;1102 1167 11B8;B151;1102 1167 11B8; 
      // (녑; 녑; 녑; 녑; 녑; ) HANGUL SYLLABLE NYEOB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB151 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB151 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11B8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB151 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11B8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_178)
  {
      // B152;B152;1102 1167 11B9;B152;1102 1167 11B9; 
      // (녒; 녒; 녒; 녒; 녒; ) HANGUL SYLLABLE NYEOBS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB152 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB152 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11B9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB152 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11B9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_179)
  {
      // B153;B153;1102 1167 11BA;B153;1102 1167 11BA; 
      // (녓; 녓; 녓; 녓; 녓; ) HANGUL SYLLABLE NYEOS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB153 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB153 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11BA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB153 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11BA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_180)
  {
      // B154;B154;1102 1167 11BB;B154;1102 1167 11BB; 
      // (녔; 녔; 녔; 녔; 녔; ) HANGUL SYLLABLE NYEOSS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB154 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB154 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11BB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB154 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11BB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_181)
  {
      // B155;B155;1102 1167 11BC;B155;1102 1167 11BC; 
      // (녕; 녕; 녕; 녕; 녕; ) HANGUL SYLLABLE NYEONG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB155 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB155 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11BC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB155 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11BC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_182)
  {
      // B156;B156;1102 1167 11BD;B156;1102 1167 11BD; 
      // (녖; 녖; 녖; 녖; 녖; ) HANGUL SYLLABLE NYEOJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB156 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB156 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11BD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB156 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11BD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_183)
  {
      // B157;B157;1102 1167 11BE;B157;1102 1167 11BE; 
      // (녗; 녗; 녗; 녗; 녗; ) HANGUL SYLLABLE NYEOC
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB157 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB157 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11BE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB157 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11BE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_184)
  {
      // B158;B158;1102 1167 11BF;B158;1102 1167 11BF; 
      // (녘; 녘; 녘; 녘; 녘; ) HANGUL SYLLABLE NYEOK
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB158 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB158 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11BF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB158 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11BF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_185)
  {
      // B159;B159;1102 1167 11C0;B159;1102 1167 11C0; 
      // (녙; 녙; 녙; 녙; 녙; ) HANGUL SYLLABLE NYEOT
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB159 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB159 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11C0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB159 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11C0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_186)
  {
      // B15A;B15A;1102 1167 11C1;B15A;1102 1167 11C1; 
      // (녚; 녚; 녚; 녚; 녚; ) HANGUL SYLLABLE NYEOP
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB15A }};
          std::array<uint32_t, 1> const c2 = {{ 0xB15A }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11C1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB15A }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11C1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_187)
  {
      // B15B;B15B;1102 1167 11C2;B15B;1102 1167 11C2; 
      // (녛; 녛; 녛; 녛; 녛; ) HANGUL SYLLABLE NYEOH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB15B }};
          std::array<uint32_t, 1> const c2 = {{ 0xB15B }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1167, 0x11C2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB15B }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1167, 0x11C2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_188)
  {
      // B15C;B15C;1102 1168;B15C;1102 1168; 
      // (녜; 녜; 녜; 녜; 녜; ) HANGUL SYLLABLE NYE
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB15C }};
          std::array<uint32_t, 1> const c2 = {{ 0xB15C }};
          std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x1168 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB15C }};
          std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x1168 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_189)
  {
      // B15D;B15D;1102 1168 11A8;B15D;1102 1168 11A8; 
      // (녝; 녝; 녝; 녝; 녝; ) HANGUL SYLLABLE NYEG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB15D }};
          std::array<uint32_t, 1> const c2 = {{ 0xB15D }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11A8 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB15D }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 0x11A8 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_190)
  {
      // B15E;B15E;1102 1168 11A9;B15E;1102 1168 11A9; 
      // (녞; 녞; 녞; 녞; 녞; ) HANGUL SYLLABLE NYEGG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB15E }};
          std::array<uint32_t, 1> const c2 = {{ 0xB15E }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11A9 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB15E }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 0x11A9 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_191)
  {
      // B15F;B15F;1102 1168 11AA;B15F;1102 1168 11AA; 
      // (녟; 녟; 녟; 녟; 녟; ) HANGUL SYLLABLE NYEGS
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB15F }};
          std::array<uint32_t, 1> const c2 = {{ 0xB15F }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11AA }};
          std::array<uint32_t, 1> const c4 = {{ 0xB15F }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 0x11AA }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_192)
  {
      // B160;B160;1102 1168 11AB;B160;1102 1168 11AB; 
      // (녠; 녠; 녠; 녠; 녠; ) HANGUL SYLLABLE NYEN
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB160 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB160 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11AB }};
          std::array<uint32_t, 1> const c4 = {{ 0xB160 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 0x11AB }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_193)
  {
      // B161;B161;1102 1168 11AC;B161;1102 1168 11AC; 
      // (녡; 녡; 녡; 녡; 녡; ) HANGUL SYLLABLE NYENJ
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB161 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB161 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11AC }};
          std::array<uint32_t, 1> const c4 = {{ 0xB161 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 0x11AC }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_194)
  {
      // B162;B162;1102 1168 11AD;B162;1102 1168 11AD; 
      // (녢; 녢; 녢; 녢; 녢; ) HANGUL SYLLABLE NYENH
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB162 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB162 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11AD }};
          std::array<uint32_t, 1> const c4 = {{ 0xB162 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 0x11AD }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_195)
  {
      // B163;B163;1102 1168 11AE;B163;1102 1168 11AE; 
      // (녣; 녣; 녣; 녣; 녣; ) HANGUL SYLLABLE NYED
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB163 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB163 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11AE }};
          std::array<uint32_t, 1> const c4 = {{ 0xB163 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 0x11AE }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_196)
  {
      // B164;B164;1102 1168 11AF;B164;1102 1168 11AF; 
      // (녤; 녤; 녤; 녤; 녤; ) HANGUL SYLLABLE NYEL
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB164 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB164 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11AF }};
          std::array<uint32_t, 1> const c4 = {{ 0xB164 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 0x11AF }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_197)
  {
      // B165;B165;1102 1168 11B0;B165;1102 1168 11B0; 
      // (녥; 녥; 녥; 녥; 녥; ) HANGUL SYLLABLE NYELG
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB165 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB165 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11B0 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB165 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 0x11B0 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_198)
  {
      // B166;B166;1102 1168 11B1;B166;1102 1168 11B1; 
      // (녦; 녦; 녦; 녦; 녦; ) HANGUL SYLLABLE NYELM
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB166 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB166 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11B1 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB166 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 0x11B1 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  TEST(normalization, nfkd_018_199)
  {
      // B167;B167;1102 1168 11B2;B167;1102 1168 11B2; 
      // (녧; 녧; 녧; 녧; 녧; ) HANGUL SYLLABLE NYELB
      {
          std::array<uint32_t, 1> const c1 = {{ 0xB167 }};
          std::array<uint32_t, 1> const c2 = {{ 0xB167 }};
          std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11B2 }};
          std::array<uint32_t, 1> const c4 = {{ 0xB167 }};
          std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 0x11B2 }};
  
          EXPECT_TRUE(boost::text::normalized_nfc(c2.begin(), c2.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c2.begin(), c2.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c3.begin(), c3.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c3.begin(), c3.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfc(c4.begin(), c4.end()));
          EXPECT_TRUE(boost::text::normalized_nfkc(c4.begin(), c4.end()));
  
          EXPECT_TRUE(boost::text::normalized_nfd(c5.begin(), c5.end()));
          EXPECT_TRUE(boost::text::normalized_nfkd(c5.begin(), c5.end()));
  
  
  
          {
              boost::text::string str = boost::text::to_string(c1.begin(), c1.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
          {
              boost::text::string str = boost::text::to_string(c5.begin(), c5.end());
              boost::text::normalize_to_nfkd(str);
              boost::text::utf32_range utf32_range(str);
              EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
              auto c5_it = c5.begin();
              int i = 0;
              for (auto x : utf32_range) {
                  EXPECT_EQ(x, *c5_it) << "iteration " << i;
                  ++c5_it;
                  ++i;
              }
          }
  
      }
  }
  
  
  