// 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, nfd_019_000)
{
    // B168;B168;1102 1168 11B3;B168;1102 1168 11B3; 
    // (녨; 녨; 녨; 녨; 녨; ) HANGUL SYLLABLE NYELS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB168 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB168 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11B3 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB168 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_001)
{
    // B169;B169;1102 1168 11B4;B169;1102 1168 11B4; 
    // (녩; 녩; 녩; 녩; 녩; ) HANGUL SYLLABLE NYELT
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB169 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB169 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11B4 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB169 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_002)
{
    // B16A;B16A;1102 1168 11B5;B16A;1102 1168 11B5; 
    // (녪; 녪; 녪; 녪; 녪; ) HANGUL SYLLABLE NYELP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB16A }};
        std::array<uint32_t, 1> const c2 = {{ 0xB16A }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11B5 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB16A }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_003)
{
    // B16B;B16B;1102 1168 11B6;B16B;1102 1168 11B6; 
    // (녫; 녫; 녫; 녫; 녫; ) HANGUL SYLLABLE NYELH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB16B }};
        std::array<uint32_t, 1> const c2 = {{ 0xB16B }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11B6 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB16B }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_004)
{
    // B16C;B16C;1102 1168 11B7;B16C;1102 1168 11B7; 
    // (녬; 녬; 녬; 녬; 녬; ) HANGUL SYLLABLE NYEM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB16C }};
        std::array<uint32_t, 1> const c2 = {{ 0xB16C }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11B7 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB16C }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_005)
{
    // B16D;B16D;1102 1168 11B8;B16D;1102 1168 11B8; 
    // (녭; 녭; 녭; 녭; 녭; ) HANGUL SYLLABLE NYEB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB16D }};
        std::array<uint32_t, 1> const c2 = {{ 0xB16D }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11B8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB16D }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_006)
{
    // B16E;B16E;1102 1168 11B9;B16E;1102 1168 11B9; 
    // (녮; 녮; 녮; 녮; 녮; ) HANGUL SYLLABLE NYEBS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB16E }};
        std::array<uint32_t, 1> const c2 = {{ 0xB16E }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11B9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB16E }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_007)
{
    // B16F;B16F;1102 1168 11BA;B16F;1102 1168 11BA; 
    // (녯; 녯; 녯; 녯; 녯; ) HANGUL SYLLABLE NYES
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB16F }};
        std::array<uint32_t, 1> const c2 = {{ 0xB16F }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11BA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB16F }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_008)
{
    // B170;B170;1102 1168 11BB;B170;1102 1168 11BB; 
    // (녰; 녰; 녰; 녰; 녰; ) HANGUL SYLLABLE NYESS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB170 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB170 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11BB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB170 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_009)
{
    // B171;B171;1102 1168 11BC;B171;1102 1168 11BC; 
    // (녱; 녱; 녱; 녱; 녱; ) HANGUL SYLLABLE NYENG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB171 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB171 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11BC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB171 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_010)
{
    // B172;B172;1102 1168 11BD;B172;1102 1168 11BD; 
    // (녲; 녲; 녲; 녲; 녲; ) HANGUL SYLLABLE NYEJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB172 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB172 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11BD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB172 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_011)
{
    // B173;B173;1102 1168 11BE;B173;1102 1168 11BE; 
    // (녳; 녳; 녳; 녳; 녳; ) HANGUL SYLLABLE NYEC
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB173 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB173 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11BE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB173 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_012)
{
    // B174;B174;1102 1168 11BF;B174;1102 1168 11BF; 
    // (녴; 녴; 녴; 녴; 녴; ) HANGUL SYLLABLE NYEK
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB174 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB174 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11BF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB174 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_013)
{
    // B175;B175;1102 1168 11C0;B175;1102 1168 11C0; 
    // (녵; 녵; 녵; 녵; 녵; ) HANGUL SYLLABLE NYET
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB175 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB175 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11C0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB175 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_014)
{
    // B176;B176;1102 1168 11C1;B176;1102 1168 11C1; 
    // (녶; 녶; 녶; 녶; 녶; ) HANGUL SYLLABLE NYEP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB176 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB176 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11C1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB176 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_015)
{
    // B177;B177;1102 1168 11C2;B177;1102 1168 11C2; 
    // (녷; 녷; 녷; 녷; 녷; ) HANGUL SYLLABLE NYEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB177 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB177 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1168, 0x11C2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB177 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1168, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_016)
{
    // B178;B178;1102 1169;B178;1102 1169; 
    // (노; 노; 노; 노; 노; ) HANGUL SYLLABLE NO
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB178 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB178 }};
        std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x1169 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB178 }};
        std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x1169 }};

        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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_017)
{
    // B179;B179;1102 1169 11A8;B179;1102 1169 11A8; 
    // (녹; 녹; 녹; 녹; 녹; ) HANGUL SYLLABLE NOG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB179 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB179 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11A8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB179 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_018)
{
    // B17A;B17A;1102 1169 11A9;B17A;1102 1169 11A9; 
    // (녺; 녺; 녺; 녺; 녺; ) HANGUL SYLLABLE NOGG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB17A }};
        std::array<uint32_t, 1> const c2 = {{ 0xB17A }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11A9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB17A }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_019)
{
    // B17B;B17B;1102 1169 11AA;B17B;1102 1169 11AA; 
    // (녻; 녻; 녻; 녻; 녻; ) HANGUL SYLLABLE NOGS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB17B }};
        std::array<uint32_t, 1> const c2 = {{ 0xB17B }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11AA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB17B }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_020)
{
    // B17C;B17C;1102 1169 11AB;B17C;1102 1169 11AB; 
    // (논; 논; 논; 논; 논; ) HANGUL SYLLABLE NON
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB17C }};
        std::array<uint32_t, 1> const c2 = {{ 0xB17C }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11AB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB17C }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_021)
{
    // B17D;B17D;1102 1169 11AC;B17D;1102 1169 11AC; 
    // (녽; 녽; 녽; 녽; 녽; ) HANGUL SYLLABLE NONJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB17D }};
        std::array<uint32_t, 1> const c2 = {{ 0xB17D }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11AC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB17D }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_022)
{
    // B17E;B17E;1102 1169 11AD;B17E;1102 1169 11AD; 
    // (녾; 녾; 녾; 녾; 녾; ) HANGUL SYLLABLE NONH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB17E }};
        std::array<uint32_t, 1> const c2 = {{ 0xB17E }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11AD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB17E }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_023)
{
    // B17F;B17F;1102 1169 11AE;B17F;1102 1169 11AE; 
    // (녿; 녿; 녿; 녿; 녿; ) HANGUL SYLLABLE NOD
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB17F }};
        std::array<uint32_t, 1> const c2 = {{ 0xB17F }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11AE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB17F }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_024)
{
    // B180;B180;1102 1169 11AF;B180;1102 1169 11AF; 
    // (놀; 놀; 놀; 놀; 놀; ) HANGUL SYLLABLE NOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB180 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB180 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11AF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB180 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_025)
{
    // B181;B181;1102 1169 11B0;B181;1102 1169 11B0; 
    // (놁; 놁; 놁; 놁; 놁; ) HANGUL SYLLABLE NOLG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB181 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB181 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11B0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB181 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_026)
{
    // B182;B182;1102 1169 11B1;B182;1102 1169 11B1; 
    // (놂; 놂; 놂; 놂; 놂; ) HANGUL SYLLABLE NOLM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB182 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB182 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11B1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB182 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_027)
{
    // B183;B183;1102 1169 11B2;B183;1102 1169 11B2; 
    // (놃; 놃; 놃; 놃; 놃; ) HANGUL SYLLABLE NOLB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB183 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB183 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11B2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB183 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_028)
{
    // B184;B184;1102 1169 11B3;B184;1102 1169 11B3; 
    // (놄; 놄; 놄; 놄; 놄; ) HANGUL SYLLABLE NOLS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB184 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB184 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11B3 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB184 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_029)
{
    // B185;B185;1102 1169 11B4;B185;1102 1169 11B4; 
    // (놅; 놅; 놅; 놅; 놅; ) HANGUL SYLLABLE NOLT
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB185 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB185 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11B4 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB185 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_030)
{
    // B186;B186;1102 1169 11B5;B186;1102 1169 11B5; 
    // (놆; 놆; 놆; 놆; 놆; ) HANGUL SYLLABLE NOLP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB186 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB186 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11B5 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB186 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_031)
{
    // B187;B187;1102 1169 11B6;B187;1102 1169 11B6; 
    // (놇; 놇; 놇; 놇; 놇; ) HANGUL SYLLABLE NOLH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB187 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB187 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11B6 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB187 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_032)
{
    // B188;B188;1102 1169 11B7;B188;1102 1169 11B7; 
    // (놈; 놈; 놈; 놈; 놈; ) HANGUL SYLLABLE NOM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB188 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB188 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11B7 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB188 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_033)
{
    // B189;B189;1102 1169 11B8;B189;1102 1169 11B8; 
    // (놉; 놉; 놉; 놉; 놉; ) HANGUL SYLLABLE NOB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB189 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB189 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11B8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB189 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_034)
{
    // B18A;B18A;1102 1169 11B9;B18A;1102 1169 11B9; 
    // (놊; 놊; 놊; 놊; 놊; ) HANGUL SYLLABLE NOBS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB18A }};
        std::array<uint32_t, 1> const c2 = {{ 0xB18A }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11B9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB18A }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_035)
{
    // B18B;B18B;1102 1169 11BA;B18B;1102 1169 11BA; 
    // (놋; 놋; 놋; 놋; 놋; ) HANGUL SYLLABLE NOS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB18B }};
        std::array<uint32_t, 1> const c2 = {{ 0xB18B }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11BA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB18B }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_036)
{
    // B18C;B18C;1102 1169 11BB;B18C;1102 1169 11BB; 
    // (놌; 놌; 놌; 놌; 놌; ) HANGUL SYLLABLE NOSS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB18C }};
        std::array<uint32_t, 1> const c2 = {{ 0xB18C }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11BB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB18C }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_037)
{
    // B18D;B18D;1102 1169 11BC;B18D;1102 1169 11BC; 
    // (농; 농; 농; 농; 농; ) HANGUL SYLLABLE NONG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB18D }};
        std::array<uint32_t, 1> const c2 = {{ 0xB18D }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11BC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB18D }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_038)
{
    // B18E;B18E;1102 1169 11BD;B18E;1102 1169 11BD; 
    // (놎; 놎; 놎; 놎; 놎; ) HANGUL SYLLABLE NOJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB18E }};
        std::array<uint32_t, 1> const c2 = {{ 0xB18E }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11BD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB18E }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_039)
{
    // B18F;B18F;1102 1169 11BE;B18F;1102 1169 11BE; 
    // (놏; 놏; 놏; 놏; 놏; ) HANGUL SYLLABLE NOC
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB18F }};
        std::array<uint32_t, 1> const c2 = {{ 0xB18F }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11BE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB18F }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_040)
{
    // B190;B190;1102 1169 11BF;B190;1102 1169 11BF; 
    // (놐; 놐; 놐; 놐; 놐; ) HANGUL SYLLABLE NOK
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB190 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB190 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11BF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB190 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_041)
{
    // B191;B191;1102 1169 11C0;B191;1102 1169 11C0; 
    // (놑; 놑; 놑; 놑; 놑; ) HANGUL SYLLABLE NOT
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB191 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB191 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11C0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB191 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_042)
{
    // B192;B192;1102 1169 11C1;B192;1102 1169 11C1; 
    // (높; 높; 높; 높; 높; ) HANGUL SYLLABLE NOP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB192 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB192 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11C1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB192 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_043)
{
    // B193;B193;1102 1169 11C2;B193;1102 1169 11C2; 
    // (놓; 놓; 놓; 놓; 놓; ) HANGUL SYLLABLE NOH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB193 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB193 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x1169, 0x11C2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB193 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x1169, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_044)
{
    // B194;B194;1102 116A;B194;1102 116A; 
    // (놔; 놔; 놔; 놔; 놔; ) HANGUL SYLLABLE NWA
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB194 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB194 }};
        std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x116A }};
        std::array<uint32_t, 1> const c4 = {{ 0xB194 }};
        std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x116A }};

        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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_045)
{
    // B195;B195;1102 116A 11A8;B195;1102 116A 11A8; 
    // (놕; 놕; 놕; 놕; 놕; ) HANGUL SYLLABLE NWAG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB195 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB195 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11A8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB195 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_046)
{
    // B196;B196;1102 116A 11A9;B196;1102 116A 11A9; 
    // (놖; 놖; 놖; 놖; 놖; ) HANGUL SYLLABLE NWAGG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB196 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB196 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11A9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB196 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_047)
{
    // B197;B197;1102 116A 11AA;B197;1102 116A 11AA; 
    // (놗; 놗; 놗; 놗; 놗; ) HANGUL SYLLABLE NWAGS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB197 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB197 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11AA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB197 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_048)
{
    // B198;B198;1102 116A 11AB;B198;1102 116A 11AB; 
    // (놘; 놘; 놘; 놘; 놘; ) HANGUL SYLLABLE NWAN
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB198 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB198 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11AB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB198 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_049)
{
    // B199;B199;1102 116A 11AC;B199;1102 116A 11AC; 
    // (놙; 놙; 놙; 놙; 놙; ) HANGUL SYLLABLE NWANJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB199 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB199 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11AC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB199 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_050)
{
    // B19A;B19A;1102 116A 11AD;B19A;1102 116A 11AD; 
    // (놚; 놚; 놚; 놚; 놚; ) HANGUL SYLLABLE NWANH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB19A }};
        std::array<uint32_t, 1> const c2 = {{ 0xB19A }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11AD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB19A }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_051)
{
    // B19B;B19B;1102 116A 11AE;B19B;1102 116A 11AE; 
    // (놛; 놛; 놛; 놛; 놛; ) HANGUL SYLLABLE NWAD
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB19B }};
        std::array<uint32_t, 1> const c2 = {{ 0xB19B }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11AE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB19B }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_052)
{
    // B19C;B19C;1102 116A 11AF;B19C;1102 116A 11AF; 
    // (놜; 놜; 놜; 놜; 놜; ) HANGUL SYLLABLE NWAL
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB19C }};
        std::array<uint32_t, 1> const c2 = {{ 0xB19C }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11AF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB19C }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_053)
{
    // B19D;B19D;1102 116A 11B0;B19D;1102 116A 11B0; 
    // (놝; 놝; 놝; 놝; 놝; ) HANGUL SYLLABLE NWALG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB19D }};
        std::array<uint32_t, 1> const c2 = {{ 0xB19D }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11B0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB19D }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_054)
{
    // B19E;B19E;1102 116A 11B1;B19E;1102 116A 11B1; 
    // (놞; 놞; 놞; 놞; 놞; ) HANGUL SYLLABLE NWALM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB19E }};
        std::array<uint32_t, 1> const c2 = {{ 0xB19E }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11B1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB19E }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_055)
{
    // B19F;B19F;1102 116A 11B2;B19F;1102 116A 11B2; 
    // (놟; 놟; 놟; 놟; 놟; ) HANGUL SYLLABLE NWALB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB19F }};
        std::array<uint32_t, 1> const c2 = {{ 0xB19F }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11B2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB19F }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_056)
{
    // B1A0;B1A0;1102 116A 11B3;B1A0;1102 116A 11B3; 
    // (놠; 놠; 놠; 놠; 놠; ) HANGUL SYLLABLE NWALS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1A0 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1A0 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11B3 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1A0 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_057)
{
    // B1A1;B1A1;1102 116A 11B4;B1A1;1102 116A 11B4; 
    // (놡; 놡; 놡; 놡; 놡; ) HANGUL SYLLABLE NWALT
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1A1 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1A1 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11B4 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1A1 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_058)
{
    // B1A2;B1A2;1102 116A 11B5;B1A2;1102 116A 11B5; 
    // (놢; 놢; 놢; 놢; 놢; ) HANGUL SYLLABLE NWALP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1A2 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1A2 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11B5 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1A2 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_059)
{
    // B1A3;B1A3;1102 116A 11B6;B1A3;1102 116A 11B6; 
    // (놣; 놣; 놣; 놣; 놣; ) HANGUL SYLLABLE NWALH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1A3 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1A3 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11B6 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1A3 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_060)
{
    // B1A4;B1A4;1102 116A 11B7;B1A4;1102 116A 11B7; 
    // (놤; 놤; 놤; 놤; 놤; ) HANGUL SYLLABLE NWAM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1A4 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1A4 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11B7 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1A4 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_061)
{
    // B1A5;B1A5;1102 116A 11B8;B1A5;1102 116A 11B8; 
    // (놥; 놥; 놥; 놥; 놥; ) HANGUL SYLLABLE NWAB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1A5 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1A5 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11B8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1A5 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_062)
{
    // B1A6;B1A6;1102 116A 11B9;B1A6;1102 116A 11B9; 
    // (놦; 놦; 놦; 놦; 놦; ) HANGUL SYLLABLE NWABS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1A6 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1A6 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11B9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1A6 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_063)
{
    // B1A7;B1A7;1102 116A 11BA;B1A7;1102 116A 11BA; 
    // (놧; 놧; 놧; 놧; 놧; ) HANGUL SYLLABLE NWAS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1A7 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1A7 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11BA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1A7 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_064)
{
    // B1A8;B1A8;1102 116A 11BB;B1A8;1102 116A 11BB; 
    // (놨; 놨; 놨; 놨; 놨; ) HANGUL SYLLABLE NWASS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1A8 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1A8 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11BB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1A8 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_065)
{
    // B1A9;B1A9;1102 116A 11BC;B1A9;1102 116A 11BC; 
    // (놩; 놩; 놩; 놩; 놩; ) HANGUL SYLLABLE NWANG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1A9 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1A9 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11BC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1A9 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_066)
{
    // B1AA;B1AA;1102 116A 11BD;B1AA;1102 116A 11BD; 
    // (놪; 놪; 놪; 놪; 놪; ) HANGUL SYLLABLE NWAJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1AA }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1AA }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11BD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1AA }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_067)
{
    // B1AB;B1AB;1102 116A 11BE;B1AB;1102 116A 11BE; 
    // (놫; 놫; 놫; 놫; 놫; ) HANGUL SYLLABLE NWAC
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1AB }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1AB }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11BE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1AB }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_068)
{
    // B1AC;B1AC;1102 116A 11BF;B1AC;1102 116A 11BF; 
    // (놬; 놬; 놬; 놬; 놬; ) HANGUL SYLLABLE NWAK
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1AC }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1AC }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11BF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1AC }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_069)
{
    // B1AD;B1AD;1102 116A 11C0;B1AD;1102 116A 11C0; 
    // (놭; 놭; 놭; 놭; 놭; ) HANGUL SYLLABLE NWAT
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1AD }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1AD }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11C0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1AD }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_070)
{
    // B1AE;B1AE;1102 116A 11C1;B1AE;1102 116A 11C1; 
    // (놮; 놮; 놮; 놮; 놮; ) HANGUL SYLLABLE NWAP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1AE }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1AE }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11C1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1AE }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_071)
{
    // B1AF;B1AF;1102 116A 11C2;B1AF;1102 116A 11C2; 
    // (놯; 놯; 놯; 놯; 놯; ) HANGUL SYLLABLE NWAH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1AF }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1AF }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116A, 0x11C2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1AF }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116A, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_072)
{
    // B1B0;B1B0;1102 116B;B1B0;1102 116B; 
    // (놰; 놰; 놰; 놰; 놰; ) HANGUL SYLLABLE NWAE
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1B0 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1B0 }};
        std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x116B }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1B0 }};
        std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x116B }};

        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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_073)
{
    // B1B1;B1B1;1102 116B 11A8;B1B1;1102 116B 11A8; 
    // (놱; 놱; 놱; 놱; 놱; ) HANGUL SYLLABLE NWAEG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1B1 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1B1 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11A8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1B1 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_074)
{
    // B1B2;B1B2;1102 116B 11A9;B1B2;1102 116B 11A9; 
    // (놲; 놲; 놲; 놲; 놲; ) HANGUL SYLLABLE NWAEGG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1B2 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1B2 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11A9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1B2 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_075)
{
    // B1B3;B1B3;1102 116B 11AA;B1B3;1102 116B 11AA; 
    // (놳; 놳; 놳; 놳; 놳; ) HANGUL SYLLABLE NWAEGS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1B3 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1B3 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11AA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1B3 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_076)
{
    // B1B4;B1B4;1102 116B 11AB;B1B4;1102 116B 11AB; 
    // (놴; 놴; 놴; 놴; 놴; ) HANGUL SYLLABLE NWAEN
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1B4 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1B4 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11AB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1B4 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_077)
{
    // B1B5;B1B5;1102 116B 11AC;B1B5;1102 116B 11AC; 
    // (놵; 놵; 놵; 놵; 놵; ) HANGUL SYLLABLE NWAENJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1B5 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1B5 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11AC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1B5 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_078)
{
    // B1B6;B1B6;1102 116B 11AD;B1B6;1102 116B 11AD; 
    // (놶; 놶; 놶; 놶; 놶; ) HANGUL SYLLABLE NWAENH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1B6 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1B6 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11AD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1B6 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_079)
{
    // B1B7;B1B7;1102 116B 11AE;B1B7;1102 116B 11AE; 
    // (놷; 놷; 놷; 놷; 놷; ) HANGUL SYLLABLE NWAED
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1B7 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1B7 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11AE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1B7 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_080)
{
    // B1B8;B1B8;1102 116B 11AF;B1B8;1102 116B 11AF; 
    // (놸; 놸; 놸; 놸; 놸; ) HANGUL SYLLABLE NWAEL
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1B8 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1B8 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11AF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1B8 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_081)
{
    // B1B9;B1B9;1102 116B 11B0;B1B9;1102 116B 11B0; 
    // (놹; 놹; 놹; 놹; 놹; ) HANGUL SYLLABLE NWAELG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1B9 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1B9 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11B0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1B9 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_082)
{
    // B1BA;B1BA;1102 116B 11B1;B1BA;1102 116B 11B1; 
    // (놺; 놺; 놺; 놺; 놺; ) HANGUL SYLLABLE NWAELM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1BA }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1BA }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11B1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1BA }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_083)
{
    // B1BB;B1BB;1102 116B 11B2;B1BB;1102 116B 11B2; 
    // (놻; 놻; 놻; 놻; 놻; ) HANGUL SYLLABLE NWAELB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1BB }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1BB }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11B2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1BB }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_084)
{
    // B1BC;B1BC;1102 116B 11B3;B1BC;1102 116B 11B3; 
    // (놼; 놼; 놼; 놼; 놼; ) HANGUL SYLLABLE NWAELS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1BC }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1BC }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11B3 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1BC }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_085)
{
    // B1BD;B1BD;1102 116B 11B4;B1BD;1102 116B 11B4; 
    // (놽; 놽; 놽; 놽; 놽; ) HANGUL SYLLABLE NWAELT
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1BD }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1BD }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11B4 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1BD }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_086)
{
    // B1BE;B1BE;1102 116B 11B5;B1BE;1102 116B 11B5; 
    // (놾; 놾; 놾; 놾; 놾; ) HANGUL SYLLABLE NWAELP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1BE }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1BE }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11B5 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1BE }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_087)
{
    // B1BF;B1BF;1102 116B 11B6;B1BF;1102 116B 11B6; 
    // (놿; 놿; 놿; 놿; 놿; ) HANGUL SYLLABLE NWAELH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1BF }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1BF }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11B6 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1BF }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_088)
{
    // B1C0;B1C0;1102 116B 11B7;B1C0;1102 116B 11B7; 
    // (뇀; 뇀; 뇀; 뇀; 뇀; ) HANGUL SYLLABLE NWAEM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1C0 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1C0 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11B7 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1C0 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_089)
{
    // B1C1;B1C1;1102 116B 11B8;B1C1;1102 116B 11B8; 
    // (뇁; 뇁; 뇁; 뇁; 뇁; ) HANGUL SYLLABLE NWAEB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1C1 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1C1 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11B8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1C1 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_090)
{
    // B1C2;B1C2;1102 116B 11B9;B1C2;1102 116B 11B9; 
    // (뇂; 뇂; 뇂; 뇂; 뇂; ) HANGUL SYLLABLE NWAEBS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1C2 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1C2 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11B9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1C2 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_091)
{
    // B1C3;B1C3;1102 116B 11BA;B1C3;1102 116B 11BA; 
    // (뇃; 뇃; 뇃; 뇃; 뇃; ) HANGUL SYLLABLE NWAES
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1C3 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1C3 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11BA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1C3 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_092)
{
    // B1C4;B1C4;1102 116B 11BB;B1C4;1102 116B 11BB; 
    // (뇄; 뇄; 뇄; 뇄; 뇄; ) HANGUL SYLLABLE NWAESS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1C4 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1C4 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11BB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1C4 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_093)
{
    // B1C5;B1C5;1102 116B 11BC;B1C5;1102 116B 11BC; 
    // (뇅; 뇅; 뇅; 뇅; 뇅; ) HANGUL SYLLABLE NWAENG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1C5 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1C5 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11BC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1C5 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_094)
{
    // B1C6;B1C6;1102 116B 11BD;B1C6;1102 116B 11BD; 
    // (뇆; 뇆; 뇆; 뇆; 뇆; ) HANGUL SYLLABLE NWAEJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1C6 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1C6 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11BD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1C6 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_095)
{
    // B1C7;B1C7;1102 116B 11BE;B1C7;1102 116B 11BE; 
    // (뇇; 뇇; 뇇; 뇇; 뇇; ) HANGUL SYLLABLE NWAEC
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1C7 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1C7 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11BE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1C7 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_096)
{
    // B1C8;B1C8;1102 116B 11BF;B1C8;1102 116B 11BF; 
    // (뇈; 뇈; 뇈; 뇈; 뇈; ) HANGUL SYLLABLE NWAEK
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1C8 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1C8 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11BF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1C8 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_097)
{
    // B1C9;B1C9;1102 116B 11C0;B1C9;1102 116B 11C0; 
    // (뇉; 뇉; 뇉; 뇉; 뇉; ) HANGUL SYLLABLE NWAET
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1C9 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1C9 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11C0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1C9 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_098)
{
    // B1CA;B1CA;1102 116B 11C1;B1CA;1102 116B 11C1; 
    // (뇊; 뇊; 뇊; 뇊; 뇊; ) HANGUL SYLLABLE NWAEP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1CA }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1CA }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11C1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1CA }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_099)
{
    // B1CB;B1CB;1102 116B 11C2;B1CB;1102 116B 11C2; 
    // (뇋; 뇋; 뇋; 뇋; 뇋; ) HANGUL SYLLABLE NWAEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1CB }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1CB }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116B, 0x11C2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1CB }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116B, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_100)
{
    // B1CC;B1CC;1102 116C;B1CC;1102 116C; 
    // (뇌; 뇌; 뇌; 뇌; 뇌; ) HANGUL SYLLABLE NOE
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1CC }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1CC }};
        std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x116C }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1CC }};
        std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x116C }};

        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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_101)
{
    // B1CD;B1CD;1102 116C 11A8;B1CD;1102 116C 11A8; 
    // (뇍; 뇍; 뇍; 뇍; 뇍; ) HANGUL SYLLABLE NOEG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1CD }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1CD }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11A8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1CD }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_102)
{
    // B1CE;B1CE;1102 116C 11A9;B1CE;1102 116C 11A9; 
    // (뇎; 뇎; 뇎; 뇎; 뇎; ) HANGUL SYLLABLE NOEGG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1CE }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1CE }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11A9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1CE }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_103)
{
    // B1CF;B1CF;1102 116C 11AA;B1CF;1102 116C 11AA; 
    // (뇏; 뇏; 뇏; 뇏; 뇏; ) HANGUL SYLLABLE NOEGS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1CF }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1CF }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11AA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1CF }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_104)
{
    // B1D0;B1D0;1102 116C 11AB;B1D0;1102 116C 11AB; 
    // (뇐; 뇐; 뇐; 뇐; 뇐; ) HANGUL SYLLABLE NOEN
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1D0 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1D0 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11AB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1D0 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_105)
{
    // B1D1;B1D1;1102 116C 11AC;B1D1;1102 116C 11AC; 
    // (뇑; 뇑; 뇑; 뇑; 뇑; ) HANGUL SYLLABLE NOENJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1D1 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1D1 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11AC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1D1 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_106)
{
    // B1D2;B1D2;1102 116C 11AD;B1D2;1102 116C 11AD; 
    // (뇒; 뇒; 뇒; 뇒; 뇒; ) HANGUL SYLLABLE NOENH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1D2 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1D2 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11AD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1D2 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_107)
{
    // B1D3;B1D3;1102 116C 11AE;B1D3;1102 116C 11AE; 
    // (뇓; 뇓; 뇓; 뇓; 뇓; ) HANGUL SYLLABLE NOED
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1D3 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1D3 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11AE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1D3 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_108)
{
    // B1D4;B1D4;1102 116C 11AF;B1D4;1102 116C 11AF; 
    // (뇔; 뇔; 뇔; 뇔; 뇔; ) HANGUL SYLLABLE NOEL
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1D4 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1D4 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11AF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1D4 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_109)
{
    // B1D5;B1D5;1102 116C 11B0;B1D5;1102 116C 11B0; 
    // (뇕; 뇕; 뇕; 뇕; 뇕; ) HANGUL SYLLABLE NOELG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1D5 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1D5 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11B0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1D5 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_110)
{
    // B1D6;B1D6;1102 116C 11B1;B1D6;1102 116C 11B1; 
    // (뇖; 뇖; 뇖; 뇖; 뇖; ) HANGUL SYLLABLE NOELM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1D6 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1D6 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11B1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1D6 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_111)
{
    // B1D7;B1D7;1102 116C 11B2;B1D7;1102 116C 11B2; 
    // (뇗; 뇗; 뇗; 뇗; 뇗; ) HANGUL SYLLABLE NOELB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1D7 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1D7 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11B2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1D7 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_112)
{
    // B1D8;B1D8;1102 116C 11B3;B1D8;1102 116C 11B3; 
    // (뇘; 뇘; 뇘; 뇘; 뇘; ) HANGUL SYLLABLE NOELS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1D8 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1D8 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11B3 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1D8 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_113)
{
    // B1D9;B1D9;1102 116C 11B4;B1D9;1102 116C 11B4; 
    // (뇙; 뇙; 뇙; 뇙; 뇙; ) HANGUL SYLLABLE NOELT
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1D9 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1D9 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11B4 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1D9 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_114)
{
    // B1DA;B1DA;1102 116C 11B5;B1DA;1102 116C 11B5; 
    // (뇚; 뇚; 뇚; 뇚; 뇚; ) HANGUL SYLLABLE NOELP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1DA }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1DA }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11B5 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1DA }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_115)
{
    // B1DB;B1DB;1102 116C 11B6;B1DB;1102 116C 11B6; 
    // (뇛; 뇛; 뇛; 뇛; 뇛; ) HANGUL SYLLABLE NOELH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1DB }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1DB }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11B6 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1DB }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_116)
{
    // B1DC;B1DC;1102 116C 11B7;B1DC;1102 116C 11B7; 
    // (뇜; 뇜; 뇜; 뇜; 뇜; ) HANGUL SYLLABLE NOEM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1DC }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1DC }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11B7 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1DC }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_117)
{
    // B1DD;B1DD;1102 116C 11B8;B1DD;1102 116C 11B8; 
    // (뇝; 뇝; 뇝; 뇝; 뇝; ) HANGUL SYLLABLE NOEB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1DD }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1DD }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11B8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1DD }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_118)
{
    // B1DE;B1DE;1102 116C 11B9;B1DE;1102 116C 11B9; 
    // (뇞; 뇞; 뇞; 뇞; 뇞; ) HANGUL SYLLABLE NOEBS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1DE }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1DE }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11B9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1DE }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_119)
{
    // B1DF;B1DF;1102 116C 11BA;B1DF;1102 116C 11BA; 
    // (뇟; 뇟; 뇟; 뇟; 뇟; ) HANGUL SYLLABLE NOES
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1DF }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1DF }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11BA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1DF }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_120)
{
    // B1E0;B1E0;1102 116C 11BB;B1E0;1102 116C 11BB; 
    // (뇠; 뇠; 뇠; 뇠; 뇠; ) HANGUL SYLLABLE NOESS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1E0 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1E0 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11BB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1E0 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_121)
{
    // B1E1;B1E1;1102 116C 11BC;B1E1;1102 116C 11BC; 
    // (뇡; 뇡; 뇡; 뇡; 뇡; ) HANGUL SYLLABLE NOENG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1E1 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1E1 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11BC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1E1 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_122)
{
    // B1E2;B1E2;1102 116C 11BD;B1E2;1102 116C 11BD; 
    // (뇢; 뇢; 뇢; 뇢; 뇢; ) HANGUL SYLLABLE NOEJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1E2 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1E2 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11BD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1E2 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_123)
{
    // B1E3;B1E3;1102 116C 11BE;B1E3;1102 116C 11BE; 
    // (뇣; 뇣; 뇣; 뇣; 뇣; ) HANGUL SYLLABLE NOEC
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1E3 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1E3 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11BE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1E3 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_124)
{
    // B1E4;B1E4;1102 116C 11BF;B1E4;1102 116C 11BF; 
    // (뇤; 뇤; 뇤; 뇤; 뇤; ) HANGUL SYLLABLE NOEK
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1E4 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1E4 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11BF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1E4 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_125)
{
    // B1E5;B1E5;1102 116C 11C0;B1E5;1102 116C 11C0; 
    // (뇥; 뇥; 뇥; 뇥; 뇥; ) HANGUL SYLLABLE NOET
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1E5 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1E5 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11C0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1E5 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_126)
{
    // B1E6;B1E6;1102 116C 11C1;B1E6;1102 116C 11C1; 
    // (뇦; 뇦; 뇦; 뇦; 뇦; ) HANGUL SYLLABLE NOEP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1E6 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1E6 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11C1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1E6 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_127)
{
    // B1E7;B1E7;1102 116C 11C2;B1E7;1102 116C 11C2; 
    // (뇧; 뇧; 뇧; 뇧; 뇧; ) HANGUL SYLLABLE NOEH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1E7 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1E7 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116C, 0x11C2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1E7 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116C, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_128)
{
    // B1E8;B1E8;1102 116D;B1E8;1102 116D; 
    // (뇨; 뇨; 뇨; 뇨; 뇨; ) HANGUL SYLLABLE NYO
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1E8 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1E8 }};
        std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x116D }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1E8 }};
        std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x116D }};

        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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_129)
{
    // B1E9;B1E9;1102 116D 11A8;B1E9;1102 116D 11A8; 
    // (뇩; 뇩; 뇩; 뇩; 뇩; ) HANGUL SYLLABLE NYOG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1E9 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1E9 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11A8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1E9 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_130)
{
    // B1EA;B1EA;1102 116D 11A9;B1EA;1102 116D 11A9; 
    // (뇪; 뇪; 뇪; 뇪; 뇪; ) HANGUL SYLLABLE NYOGG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1EA }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1EA }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11A9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1EA }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_131)
{
    // B1EB;B1EB;1102 116D 11AA;B1EB;1102 116D 11AA; 
    // (뇫; 뇫; 뇫; 뇫; 뇫; ) HANGUL SYLLABLE NYOGS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1EB }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1EB }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11AA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1EB }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_132)
{
    // B1EC;B1EC;1102 116D 11AB;B1EC;1102 116D 11AB; 
    // (뇬; 뇬; 뇬; 뇬; 뇬; ) HANGUL SYLLABLE NYON
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1EC }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1EC }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11AB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1EC }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_133)
{
    // B1ED;B1ED;1102 116D 11AC;B1ED;1102 116D 11AC; 
    // (뇭; 뇭; 뇭; 뇭; 뇭; ) HANGUL SYLLABLE NYONJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1ED }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1ED }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11AC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1ED }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_134)
{
    // B1EE;B1EE;1102 116D 11AD;B1EE;1102 116D 11AD; 
    // (뇮; 뇮; 뇮; 뇮; 뇮; ) HANGUL SYLLABLE NYONH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1EE }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1EE }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11AD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1EE }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_135)
{
    // B1EF;B1EF;1102 116D 11AE;B1EF;1102 116D 11AE; 
    // (뇯; 뇯; 뇯; 뇯; 뇯; ) HANGUL SYLLABLE NYOD
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1EF }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1EF }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11AE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1EF }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_136)
{
    // B1F0;B1F0;1102 116D 11AF;B1F0;1102 116D 11AF; 
    // (뇰; 뇰; 뇰; 뇰; 뇰; ) HANGUL SYLLABLE NYOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1F0 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1F0 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11AF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1F0 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_137)
{
    // B1F1;B1F1;1102 116D 11B0;B1F1;1102 116D 11B0; 
    // (뇱; 뇱; 뇱; 뇱; 뇱; ) HANGUL SYLLABLE NYOLG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1F1 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1F1 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11B0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1F1 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_138)
{
    // B1F2;B1F2;1102 116D 11B1;B1F2;1102 116D 11B1; 
    // (뇲; 뇲; 뇲; 뇲; 뇲; ) HANGUL SYLLABLE NYOLM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1F2 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1F2 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11B1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1F2 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_139)
{
    // B1F3;B1F3;1102 116D 11B2;B1F3;1102 116D 11B2; 
    // (뇳; 뇳; 뇳; 뇳; 뇳; ) HANGUL SYLLABLE NYOLB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1F3 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1F3 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11B2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1F3 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_140)
{
    // B1F4;B1F4;1102 116D 11B3;B1F4;1102 116D 11B3; 
    // (뇴; 뇴; 뇴; 뇴; 뇴; ) HANGUL SYLLABLE NYOLS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1F4 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1F4 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11B3 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1F4 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_141)
{
    // B1F5;B1F5;1102 116D 11B4;B1F5;1102 116D 11B4; 
    // (뇵; 뇵; 뇵; 뇵; 뇵; ) HANGUL SYLLABLE NYOLT
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1F5 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1F5 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11B4 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1F5 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_142)
{
    // B1F6;B1F6;1102 116D 11B5;B1F6;1102 116D 11B5; 
    // (뇶; 뇶; 뇶; 뇶; 뇶; ) HANGUL SYLLABLE NYOLP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1F6 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1F6 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11B5 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1F6 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_143)
{
    // B1F7;B1F7;1102 116D 11B6;B1F7;1102 116D 11B6; 
    // (뇷; 뇷; 뇷; 뇷; 뇷; ) HANGUL SYLLABLE NYOLH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1F7 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1F7 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11B6 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1F7 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_144)
{
    // B1F8;B1F8;1102 116D 11B7;B1F8;1102 116D 11B7; 
    // (뇸; 뇸; 뇸; 뇸; 뇸; ) HANGUL SYLLABLE NYOM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1F8 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1F8 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11B7 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1F8 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_145)
{
    // B1F9;B1F9;1102 116D 11B8;B1F9;1102 116D 11B8; 
    // (뇹; 뇹; 뇹; 뇹; 뇹; ) HANGUL SYLLABLE NYOB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1F9 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1F9 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11B8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1F9 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_146)
{
    // B1FA;B1FA;1102 116D 11B9;B1FA;1102 116D 11B9; 
    // (뇺; 뇺; 뇺; 뇺; 뇺; ) HANGUL SYLLABLE NYOBS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1FA }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1FA }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11B9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1FA }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_147)
{
    // B1FB;B1FB;1102 116D 11BA;B1FB;1102 116D 11BA; 
    // (뇻; 뇻; 뇻; 뇻; 뇻; ) HANGUL SYLLABLE NYOS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1FB }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1FB }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11BA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1FB }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_148)
{
    // B1FC;B1FC;1102 116D 11BB;B1FC;1102 116D 11BB; 
    // (뇼; 뇼; 뇼; 뇼; 뇼; ) HANGUL SYLLABLE NYOSS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1FC }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1FC }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11BB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1FC }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_149)
{
    // B1FD;B1FD;1102 116D 11BC;B1FD;1102 116D 11BC; 
    // (뇽; 뇽; 뇽; 뇽; 뇽; ) HANGUL SYLLABLE NYONG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1FD }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1FD }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11BC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1FD }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_150)
{
    // B1FE;B1FE;1102 116D 11BD;B1FE;1102 116D 11BD; 
    // (뇾; 뇾; 뇾; 뇾; 뇾; ) HANGUL SYLLABLE NYOJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1FE }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1FE }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11BD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1FE }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_151)
{
    // B1FF;B1FF;1102 116D 11BE;B1FF;1102 116D 11BE; 
    // (뇿; 뇿; 뇿; 뇿; 뇿; ) HANGUL SYLLABLE NYOC
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB1FF }};
        std::array<uint32_t, 1> const c2 = {{ 0xB1FF }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11BE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB1FF }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_152)
{
    // B200;B200;1102 116D 11BF;B200;1102 116D 11BF; 
    // (눀; 눀; 눀; 눀; 눀; ) HANGUL SYLLABLE NYOK
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB200 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB200 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11BF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB200 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_153)
{
    // B201;B201;1102 116D 11C0;B201;1102 116D 11C0; 
    // (눁; 눁; 눁; 눁; 눁; ) HANGUL SYLLABLE NYOT
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB201 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB201 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11C0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB201 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_154)
{
    // B202;B202;1102 116D 11C1;B202;1102 116D 11C1; 
    // (눂; 눂; 눂; 눂; 눂; ) HANGUL SYLLABLE NYOP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB202 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB202 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11C1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB202 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_155)
{
    // B203;B203;1102 116D 11C2;B203;1102 116D 11C2; 
    // (눃; 눃; 눃; 눃; 눃; ) HANGUL SYLLABLE NYOH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB203 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB203 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116D, 0x11C2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB203 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116D, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_156)
{
    // B204;B204;1102 116E;B204;1102 116E; 
    // (누; 누; 누; 누; 누; ) HANGUL SYLLABLE NU
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB204 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB204 }};
        std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x116E }};
        std::array<uint32_t, 1> const c4 = {{ 0xB204 }};
        std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x116E }};

        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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_157)
{
    // B205;B205;1102 116E 11A8;B205;1102 116E 11A8; 
    // (눅; 눅; 눅; 눅; 눅; ) HANGUL SYLLABLE NUG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB205 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB205 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11A8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB205 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_158)
{
    // B206;B206;1102 116E 11A9;B206;1102 116E 11A9; 
    // (눆; 눆; 눆; 눆; 눆; ) HANGUL SYLLABLE NUGG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB206 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB206 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11A9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB206 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_159)
{
    // B207;B207;1102 116E 11AA;B207;1102 116E 11AA; 
    // (눇; 눇; 눇; 눇; 눇; ) HANGUL SYLLABLE NUGS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB207 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB207 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11AA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB207 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_160)
{
    // B208;B208;1102 116E 11AB;B208;1102 116E 11AB; 
    // (눈; 눈; 눈; 눈; 눈; ) HANGUL SYLLABLE NUN
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB208 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB208 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11AB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB208 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_161)
{
    // B209;B209;1102 116E 11AC;B209;1102 116E 11AC; 
    // (눉; 눉; 눉; 눉; 눉; ) HANGUL SYLLABLE NUNJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB209 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB209 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11AC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB209 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_162)
{
    // B20A;B20A;1102 116E 11AD;B20A;1102 116E 11AD; 
    // (눊; 눊; 눊; 눊; 눊; ) HANGUL SYLLABLE NUNH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB20A }};
        std::array<uint32_t, 1> const c2 = {{ 0xB20A }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11AD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB20A }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_163)
{
    // B20B;B20B;1102 116E 11AE;B20B;1102 116E 11AE; 
    // (눋; 눋; 눋; 눋; 눋; ) HANGUL SYLLABLE NUD
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB20B }};
        std::array<uint32_t, 1> const c2 = {{ 0xB20B }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11AE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB20B }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_164)
{
    // B20C;B20C;1102 116E 11AF;B20C;1102 116E 11AF; 
    // (눌; 눌; 눌; 눌; 눌; ) HANGUL SYLLABLE NUL
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB20C }};
        std::array<uint32_t, 1> const c2 = {{ 0xB20C }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11AF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB20C }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_165)
{
    // B20D;B20D;1102 116E 11B0;B20D;1102 116E 11B0; 
    // (눍; 눍; 눍; 눍; 눍; ) HANGUL SYLLABLE NULG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB20D }};
        std::array<uint32_t, 1> const c2 = {{ 0xB20D }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11B0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB20D }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_166)
{
    // B20E;B20E;1102 116E 11B1;B20E;1102 116E 11B1; 
    // (눎; 눎; 눎; 눎; 눎; ) HANGUL SYLLABLE NULM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB20E }};
        std::array<uint32_t, 1> const c2 = {{ 0xB20E }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11B1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB20E }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_167)
{
    // B20F;B20F;1102 116E 11B2;B20F;1102 116E 11B2; 
    // (눏; 눏; 눏; 눏; 눏; ) HANGUL SYLLABLE NULB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB20F }};
        std::array<uint32_t, 1> const c2 = {{ 0xB20F }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11B2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB20F }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_168)
{
    // B210;B210;1102 116E 11B3;B210;1102 116E 11B3; 
    // (눐; 눐; 눐; 눐; 눐; ) HANGUL SYLLABLE NULS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB210 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB210 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11B3 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB210 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_169)
{
    // B211;B211;1102 116E 11B4;B211;1102 116E 11B4; 
    // (눑; 눑; 눑; 눑; 눑; ) HANGUL SYLLABLE NULT
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB211 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB211 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11B4 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB211 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_170)
{
    // B212;B212;1102 116E 11B5;B212;1102 116E 11B5; 
    // (눒; 눒; 눒; 눒; 눒; ) HANGUL SYLLABLE NULP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB212 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB212 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11B5 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB212 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_171)
{
    // B213;B213;1102 116E 11B6;B213;1102 116E 11B6; 
    // (눓; 눓; 눓; 눓; 눓; ) HANGUL SYLLABLE NULH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB213 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB213 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11B6 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB213 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_172)
{
    // B214;B214;1102 116E 11B7;B214;1102 116E 11B7; 
    // (눔; 눔; 눔; 눔; 눔; ) HANGUL SYLLABLE NUM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB214 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB214 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11B7 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB214 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_173)
{
    // B215;B215;1102 116E 11B8;B215;1102 116E 11B8; 
    // (눕; 눕; 눕; 눕; 눕; ) HANGUL SYLLABLE NUB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB215 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB215 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11B8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB215 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_174)
{
    // B216;B216;1102 116E 11B9;B216;1102 116E 11B9; 
    // (눖; 눖; 눖; 눖; 눖; ) HANGUL SYLLABLE NUBS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB216 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB216 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11B9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB216 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_175)
{
    // B217;B217;1102 116E 11BA;B217;1102 116E 11BA; 
    // (눗; 눗; 눗; 눗; 눗; ) HANGUL SYLLABLE NUS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB217 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB217 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11BA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB217 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_176)
{
    // B218;B218;1102 116E 11BB;B218;1102 116E 11BB; 
    // (눘; 눘; 눘; 눘; 눘; ) HANGUL SYLLABLE NUSS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB218 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB218 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11BB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB218 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_177)
{
    // B219;B219;1102 116E 11BC;B219;1102 116E 11BC; 
    // (눙; 눙; 눙; 눙; 눙; ) HANGUL SYLLABLE NUNG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB219 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB219 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11BC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB219 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_178)
{
    // B21A;B21A;1102 116E 11BD;B21A;1102 116E 11BD; 
    // (눚; 눚; 눚; 눚; 눚; ) HANGUL SYLLABLE NUJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB21A }};
        std::array<uint32_t, 1> const c2 = {{ 0xB21A }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11BD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB21A }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_179)
{
    // B21B;B21B;1102 116E 11BE;B21B;1102 116E 11BE; 
    // (눛; 눛; 눛; 눛; 눛; ) HANGUL SYLLABLE NUC
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB21B }};
        std::array<uint32_t, 1> const c2 = {{ 0xB21B }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11BE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB21B }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_180)
{
    // B21C;B21C;1102 116E 11BF;B21C;1102 116E 11BF; 
    // (눜; 눜; 눜; 눜; 눜; ) HANGUL SYLLABLE NUK
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB21C }};
        std::array<uint32_t, 1> const c2 = {{ 0xB21C }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11BF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB21C }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_181)
{
    // B21D;B21D;1102 116E 11C0;B21D;1102 116E 11C0; 
    // (눝; 눝; 눝; 눝; 눝; ) HANGUL SYLLABLE NUT
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB21D }};
        std::array<uint32_t, 1> const c2 = {{ 0xB21D }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11C0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB21D }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_182)
{
    // B21E;B21E;1102 116E 11C1;B21E;1102 116E 11C1; 
    // (눞; 눞; 눞; 눞; 눞; ) HANGUL SYLLABLE NUP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB21E }};
        std::array<uint32_t, 1> const c2 = {{ 0xB21E }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11C1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB21E }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_183)
{
    // B21F;B21F;1102 116E 11C2;B21F;1102 116E 11C2; 
    // (눟; 눟; 눟; 눟; 눟; ) HANGUL SYLLABLE NUH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB21F }};
        std::array<uint32_t, 1> const c2 = {{ 0xB21F }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116E, 0x11C2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB21F }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116E, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_184)
{
    // B220;B220;1102 116F;B220;1102 116F; 
    // (눠; 눠; 눠; 눠; 눠; ) HANGUL SYLLABLE NWEO
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB220 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB220 }};
        std::array<uint32_t, 2> const c3 = {{ 0x1102, 0x116F }};
        std::array<uint32_t, 1> const c4 = {{ 0xB220 }};
        std::array<uint32_t, 2> const c5 = {{ 0x1102, 0x116F }};

        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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_185)
{
    // B221;B221;1102 116F 11A8;B221;1102 116F 11A8; 
    // (눡; 눡; 눡; 눡; 눡; ) HANGUL SYLLABLE NWEOG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB221 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB221 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11A8 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB221 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_186)
{
    // B222;B222;1102 116F 11A9;B222;1102 116F 11A9; 
    // (눢; 눢; 눢; 눢; 눢; ) HANGUL SYLLABLE NWEOGG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB222 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB222 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11A9 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB222 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_187)
{
    // B223;B223;1102 116F 11AA;B223;1102 116F 11AA; 
    // (눣; 눣; 눣; 눣; 눣; ) HANGUL SYLLABLE NWEOGS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB223 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB223 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11AA }};
        std::array<uint32_t, 1> const c4 = {{ 0xB223 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_188)
{
    // B224;B224;1102 116F 11AB;B224;1102 116F 11AB; 
    // (눤; 눤; 눤; 눤; 눤; ) HANGUL SYLLABLE NWEON
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB224 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB224 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11AB }};
        std::array<uint32_t, 1> const c4 = {{ 0xB224 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_189)
{
    // B225;B225;1102 116F 11AC;B225;1102 116F 11AC; 
    // (눥; 눥; 눥; 눥; 눥; ) HANGUL SYLLABLE NWEONJ
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB225 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB225 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11AC }};
        std::array<uint32_t, 1> const c4 = {{ 0xB225 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_190)
{
    // B226;B226;1102 116F 11AD;B226;1102 116F 11AD; 
    // (눦; 눦; 눦; 눦; 눦; ) HANGUL SYLLABLE NWEONH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB226 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB226 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11AD }};
        std::array<uint32_t, 1> const c4 = {{ 0xB226 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_191)
{
    // B227;B227;1102 116F 11AE;B227;1102 116F 11AE; 
    // (눧; 눧; 눧; 눧; 눧; ) HANGUL SYLLABLE NWEOD
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB227 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB227 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11AE }};
        std::array<uint32_t, 1> const c4 = {{ 0xB227 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_192)
{
    // B228;B228;1102 116F 11AF;B228;1102 116F 11AF; 
    // (눨; 눨; 눨; 눨; 눨; ) HANGUL SYLLABLE NWEOL
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB228 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB228 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11AF }};
        std::array<uint32_t, 1> const c4 = {{ 0xB228 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_193)
{
    // B229;B229;1102 116F 11B0;B229;1102 116F 11B0; 
    // (눩; 눩; 눩; 눩; 눩; ) HANGUL SYLLABLE NWEOLG
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB229 }};
        std::array<uint32_t, 1> const c2 = {{ 0xB229 }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11B0 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB229 }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_194)
{
    // B22A;B22A;1102 116F 11B1;B22A;1102 116F 11B1; 
    // (눪; 눪; 눪; 눪; 눪; ) HANGUL SYLLABLE NWEOLM
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB22A }};
        std::array<uint32_t, 1> const c2 = {{ 0xB22A }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11B1 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB22A }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_195)
{
    // B22B;B22B;1102 116F 11B2;B22B;1102 116F 11B2; 
    // (눫; 눫; 눫; 눫; 눫; ) HANGUL SYLLABLE NWEOLB
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB22B }};
        std::array<uint32_t, 1> const c2 = {{ 0xB22B }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11B2 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB22B }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_196)
{
    // B22C;B22C;1102 116F 11B3;B22C;1102 116F 11B3; 
    // (눬; 눬; 눬; 눬; 눬; ) HANGUL SYLLABLE NWEOLS
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB22C }};
        std::array<uint32_t, 1> const c2 = {{ 0xB22C }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11B3 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB22C }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_197)
{
    // B22D;B22D;1102 116F 11B4;B22D;1102 116F 11B4; 
    // (눭; 눭; 눭; 눭; 눭; ) HANGUL SYLLABLE NWEOLT
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB22D }};
        std::array<uint32_t, 1> const c2 = {{ 0xB22D }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11B4 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB22D }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_198)
{
    // B22E;B22E;1102 116F 11B5;B22E;1102 116F 11B5; 
    // (눮; 눮; 눮; 눮; 눮; ) HANGUL SYLLABLE NWEOLP
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB22E }};
        std::array<uint32_t, 1> const c2 = {{ 0xB22E }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11B5 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB22E }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.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, nfd_019_199)
{
    // B22F;B22F;1102 116F 11B6;B22F;1102 116F 11B6; 
    // (눯; 눯; 눯; 눯; 눯; ) HANGUL SYLLABLE NWEOLH
    {
        std::array<uint32_t, 1> const c1 = {{ 0xB22F }};
        std::array<uint32_t, 1> const c2 = {{ 0xB22F }};
        std::array<uint32_t, 3> const c3 = {{ 0x1102, 0x116F, 0x11B6 }};
        std::array<uint32_t, 1> const c4 = {{ 0xB22F }};
        std::array<uint32_t, 3> const c5 = {{ 0x1102, 0x116F, 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c2.begin(), c2.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c3.begin(), c3.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c3.size());
            auto c3_it = c3.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c3_it) << "iteration " << i;
                ++c3_it;
                ++i;
            }
        }

        {
            boost::text::string str = boost::text::to_string(c4.begin(), c4.end());
            boost::text::normalize_to_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 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_nfd(str);
            boost::text::utf32_range utf32_range(str);
            EXPECT_EQ(std::distance(utf32_range.begin(), utf32_range.end()), c5.size());
            auto c5_it = c5.begin();
            int i = 0;
            for (auto x : utf32_range) {
                EXPECT_EQ(x, *c5_it) << "iteration " << i;
                ++c5_it;
                ++i;
            }
        }

    }
}


