text: // Copyright (C) 2020 T. Zachary Laine
  //
  // Distributed under the Boost Software License, Version 1.0. (See
  // accompanying file LICENSE_1_0.txt or copy at
  // http://www.boost.org/LICENSE_1_0.txt)
  
  // Warning! This file is autogenerated.
  #include <boost/text/collation_table.hpp>
  #include <boost/text/collate.hpp>
  #include <boost/text/data/all.hpp>
  
  #ifndef LIMIT_TESTING_FOR_CI
  #include <boost/text/save_load_table.hpp>
  
  #include <boost/filesystem.hpp>
  #endif
  
  #include <gtest/gtest.h>
  
  using namespace boost::text;
  
  auto const error = [](std::string const & s) { std::cout << s; };
  auto const warning = [](std::string const & s) {};
  
  collation_table make_save_load_table()
  {
  #ifdef LIMIT_TESTING_FOR_CI
      std::string const table_str(data::ja::standard_collation_tailoring());
      return tailored_collation_table(
          table_str,
          "ja::standard_collation_tailoring()", error, warning);
  #else
      if (!exists(boost::filesystem::path("ja_standard.table"))) {
          std::string const table_str(data::ja::standard_collation_tailoring());
          collation_table table = tailored_collation_table(
              table_str,
              "ja::standard_collation_tailoring()", error, warning);
          save_table(table, "ja_standard.table.0");
          boost::filesystem::rename("ja_standard.table.0", "ja_standard.table");
      }
      return load_table("ja_standard.table");
  #endif
  }
  collation_table const & table()
  {
      static collation_table retval = make_save_load_table();
      return retval;
  }
  TEST(tailoring, ja_standard_000_001)
  {
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x309d);
      auto const rel = std::vector<uint32_t>(1, 0x30fd);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
  }
  
  TEST(tailoring, ja_standard_000_002)
  {
  }
  
  TEST(tailoring, ja_standard_000_003)
  {
  }
  
  TEST(tailoring, ja_standard_000_004)
  {
  }
  
  TEST(tailoring, ja_standard_000_005)
  {
  }
  
  TEST(tailoring, ja_standard_000_006)
  {
  }
  
  TEST(tailoring, ja_standard_000_007)
  {
  }
  
  TEST(tailoring, ja_standard_000_008)
  {
  }
  
  TEST(tailoring, ja_standard_000_009)
  {
  }
  
  TEST(tailoring, ja_standard_000_010)
  {
  }
  
  TEST(tailoring, ja_standard_000_011)
  {
  }
  
  TEST(tailoring, ja_standard_000_012)
  {
  }
  
  TEST(tailoring, ja_standard_000_013)
  {
  }
  
  TEST(tailoring, ja_standard_000_014)
  {
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3041);
      auto const rel = std::vector<uint32_t>(1, 0x30a1);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30a1);
      auto const rel = std::vector<uint32_t>(1, 0xff67);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3042);
      auto const rel = std::vector<uint32_t>(1, 0x30a2);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30a2);
      auto const rel = std::vector<uint32_t>(1, 0xff71);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3043);
      auto const rel = std::vector<uint32_t>(1, 0x30a3);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30a3);
      auto const rel = std::vector<uint32_t>(1, 0xff68);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3044);
      auto const rel = std::vector<uint32_t>(1, 0x30a4);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30a4);
      auto const rel = std::vector<uint32_t>(1, 0xff72);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3045);
      auto const rel = std::vector<uint32_t>(1, 0x30a5);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30a5);
      auto const rel = std::vector<uint32_t>(1, 0xff69);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3046);
      auto const rel = std::vector<uint32_t>(1, 0x30a6);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30a6);
      auto const rel = std::vector<uint32_t>(1, 0xff73);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3047);
      auto const rel = std::vector<uint32_t>(1, 0x30a7);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30a7);
      auto const rel = std::vector<uint32_t>(1, 0xff6a);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3048);
      auto const rel = std::vector<uint32_t>(1, 0x30a8);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30a8);
      auto const rel = std::vector<uint32_t>(1, 0xff74);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
  }
  
  TEST(tailoring, ja_standard_000_015)
  {
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3049);
      auto const rel = std::vector<uint32_t>(1, 0x30a9);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30a9);
      auto const rel = std::vector<uint32_t>(1, 0xff6b);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x304a);
      auto const rel = std::vector<uint32_t>(1, 0x30aa);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30aa);
      auto const rel = std::vector<uint32_t>(1, 0xff75);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x304b);
      auto const rel = std::vector<uint32_t>(1, 0x30ab);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30ab);
      auto const rel = std::vector<uint32_t>(1, 0xff76);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x304d);
      auto const rel = std::vector<uint32_t>(1, 0x30ad);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30ad);
      auto const rel = std::vector<uint32_t>(1, 0xff77);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x304f);
      auto const rel = std::vector<uint32_t>(1, 0x30af);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30af);
      auto const rel = std::vector<uint32_t>(1, 0xff78);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3051);
      auto const rel = std::vector<uint32_t>(1, 0x30b1);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30b1);
      auto const rel = std::vector<uint32_t>(1, 0xff79);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3053);
      auto const rel = std::vector<uint32_t>(1, 0x30b3);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30b3);
      auto const rel = std::vector<uint32_t>(1, 0xff7a);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3055);
      auto const rel = std::vector<uint32_t>(1, 0x30b5);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30b5);
      auto const rel = std::vector<uint32_t>(1, 0xff7b);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3057);
      auto const rel = std::vector<uint32_t>(1, 0x30b7);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30b7);
      auto const rel = std::vector<uint32_t>(1, 0xff7c);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3059);
      auto const rel = std::vector<uint32_t>(1, 0x30b9);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30b9);
      auto const rel = std::vector<uint32_t>(1, 0xff7d);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x305b);
      auto const rel = std::vector<uint32_t>(1, 0x30bb);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30bb);
      auto const rel = std::vector<uint32_t>(1, 0xff7e);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x305d);
      auto const rel = std::vector<uint32_t>(1, 0x30bd);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30bd);
      auto const rel = std::vector<uint32_t>(1, 0xff7f);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x305f);
      auto const rel = std::vector<uint32_t>(1, 0x30bf);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30bf);
      auto const rel = std::vector<uint32_t>(1, 0xff80);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3061);
      auto const rel = std::vector<uint32_t>(1, 0x30c1);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30c1);
      auto const rel = std::vector<uint32_t>(1, 0xff81);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3063);
      auto const rel = std::vector<uint32_t>(1, 0x30c3);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30c3);
      auto const rel = std::vector<uint32_t>(1, 0xff6f);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3064);
      auto const rel = std::vector<uint32_t>(1, 0x30c4);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30c4);
      auto const rel = std::vector<uint32_t>(1, 0xff82);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3066);
      auto const rel = std::vector<uint32_t>(1, 0x30c6);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30c6);
      auto const rel = std::vector<uint32_t>(1, 0xff83);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
  }
  
  TEST(tailoring, ja_standard_000_016)
  {
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3068);
      auto const rel = std::vector<uint32_t>(1, 0x30c8);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30c8);
      auto const rel = std::vector<uint32_t>(1, 0xff84);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x306a);
      auto const rel = std::vector<uint32_t>(1, 0x30ca);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30ca);
      auto const rel = std::vector<uint32_t>(1, 0xff85);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x306b);
      auto const rel = std::vector<uint32_t>(1, 0x30cb);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30cb);
      auto const rel = std::vector<uint32_t>(1, 0xff86);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x306c);
      auto const rel = std::vector<uint32_t>(1, 0x30cc);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30cc);
      auto const rel = std::vector<uint32_t>(1, 0xff87);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x306d);
      auto const rel = std::vector<uint32_t>(1, 0x30cd);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30cd);
      auto const rel = std::vector<uint32_t>(1, 0xff88);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x306e);
      auto const rel = std::vector<uint32_t>(1, 0x30ce);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30ce);
      auto const rel = std::vector<uint32_t>(1, 0xff89);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x306f);
      auto const rel = std::vector<uint32_t>(1, 0x30cf);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30cf);
      auto const rel = std::vector<uint32_t>(1, 0xff8a);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3072);
      auto const rel = std::vector<uint32_t>(1, 0x30d2);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30d2);
      auto const rel = std::vector<uint32_t>(1, 0xff8b);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3075);
      auto const rel = std::vector<uint32_t>(1, 0x30d5);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30d5);
      auto const rel = std::vector<uint32_t>(1, 0xff8c);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3078);
      auto const rel = std::vector<uint32_t>(1, 0x30d8);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30d8);
      auto const rel = std::vector<uint32_t>(1, 0xff8d);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x307b);
      auto const rel = std::vector<uint32_t>(1, 0x30db);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30db);
      auto const rel = std::vector<uint32_t>(1, 0xff8e);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x307e);
      auto const rel = std::vector<uint32_t>(1, 0x30de);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30de);
      auto const rel = std::vector<uint32_t>(1, 0xff8f);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x307f);
      auto const rel = std::vector<uint32_t>(1, 0x30df);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30df);
      auto const rel = std::vector<uint32_t>(1, 0xff90);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3080);
      auto const rel = std::vector<uint32_t>(1, 0x30e0);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30e0);
      auto const rel = std::vector<uint32_t>(1, 0xff91);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3081);
      auto const rel = std::vector<uint32_t>(1, 0x30e1);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30e1);
      auto const rel = std::vector<uint32_t>(1, 0xff92);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3082);
      auto const rel = std::vector<uint32_t>(1, 0x30e2);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30e2);
      auto const rel = std::vector<uint32_t>(1, 0xff93);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3083);
      auto const rel = std::vector<uint32_t>(1, 0x30e3);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30e3);
      auto const rel = std::vector<uint32_t>(1, 0xff6c);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
  }
  
  TEST(tailoring, ja_standard_000_017)
  {
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3084);
      auto const rel = std::vector<uint32_t>(1, 0x30e4);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30e4);
      auto const rel = std::vector<uint32_t>(1, 0xff94);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3085);
      auto const rel = std::vector<uint32_t>(1, 0x30e5);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30e5);
      auto const rel = std::vector<uint32_t>(1, 0xff6d);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3086);
      auto const rel = std::vector<uint32_t>(1, 0x30e6);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30e6);
      auto const rel = std::vector<uint32_t>(1, 0xff95);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3087);
      auto const rel = std::vector<uint32_t>(1, 0x30e7);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30e7);
      auto const rel = std::vector<uint32_t>(1, 0xff6e);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3088);
      auto const rel = std::vector<uint32_t>(1, 0x30e8);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30e8);
      auto const rel = std::vector<uint32_t>(1, 0xff96);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3089);
      auto const rel = std::vector<uint32_t>(1, 0x30e9);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30e9);
      auto const rel = std::vector<uint32_t>(1, 0xff97);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x308a);
      auto const rel = std::vector<uint32_t>(1, 0x30ea);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30ea);
      auto const rel = std::vector<uint32_t>(1, 0xff98);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x308b);
      auto const rel = std::vector<uint32_t>(1, 0x30eb);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30eb);
      auto const rel = std::vector<uint32_t>(1, 0xff99);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x308c);
      auto const rel = std::vector<uint32_t>(1, 0x30ec);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30ec);
      auto const rel = std::vector<uint32_t>(1, 0xff9a);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x308d);
      auto const rel = std::vector<uint32_t>(1, 0x30ed);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30ed);
      auto const rel = std::vector<uint32_t>(1, 0xff9b);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x308e);
      auto const rel = std::vector<uint32_t>(1, 0x30ee);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x308f);
      auto const rel = std::vector<uint32_t>(1, 0x30ef);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30ef);
      auto const rel = std::vector<uint32_t>(1, 0xff9c);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3090);
      auto const rel = std::vector<uint32_t>(1, 0x30f0);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3091);
      auto const rel = std::vector<uint32_t>(1, 0x30f1);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3092);
      auto const rel = std::vector<uint32_t>(1, 0x30f2);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30f2);
      auto const rel = std::vector<uint32_t>(1, 0xff66);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3093);
      auto const rel = std::vector<uint32_t>(1, 0x30f3);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x30f3);
      auto const rel = std::vector<uint32_t>(1, 0xff9d);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3095);
      auto const rel = std::vector<uint32_t>(1, 0x30f5);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3096);
      auto const rel = std::vector<uint32_t>(1, 0x30f6);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::tertiary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::tertiary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>{0x3088, 0x308a};
      auto const rel = std::vector<uint32_t>(1, 0x309f);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::secondary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::secondary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::primary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::primary),
          0);
      }
  }
  
  TEST(tailoring, ja_standard_000_018)
  {
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>{0x30b3, 0x30c8};
      auto const rel = std::vector<uint32_t>(1, 0x30ff);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::secondary),
          -1);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::secondary),
          -1);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::primary),
          0);
      // equal to preceeding cps at next-lower strength
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::primary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0020);
      auto const rel = std::vector<uint32_t>(1, 0x3000);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x3000);
      auto const rel = std::vector<uint32_t>(1, 0xffe3);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0021);
      auto const rel = std::vector<uint32_t>(1, 0xff01);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0022);
      auto const rel = std::vector<uint32_t>(1, 0xff02);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0023);
      auto const rel = std::vector<uint32_t>(1, 0xff03);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0024);
      auto const rel = std::vector<uint32_t>(1, 0xff04);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0025);
      auto const rel = std::vector<uint32_t>(1, 0xff05);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0026);
      auto const rel = std::vector<uint32_t>(1, 0xff06);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0027);
      auto const rel = std::vector<uint32_t>(1, 0xff07);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0028);
      auto const rel = std::vector<uint32_t>(1, 0xff08);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0029);
      auto const rel = std::vector<uint32_t>(1, 0xff09);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x002a);
      auto const rel = std::vector<uint32_t>(1, 0xff0a);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x002b);
      auto const rel = std::vector<uint32_t>(1, 0xff0b);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x002c);
      auto const rel = std::vector<uint32_t>(1, 0xff0c);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x002d);
      auto const rel = std::vector<uint32_t>(1, 0xff0d);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x002e);
      auto const rel = std::vector<uint32_t>(1, 0xff0e);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x002f);
      auto const rel = std::vector<uint32_t>(1, 0xff0f);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0030);
      auto const rel = std::vector<uint32_t>(1, 0xff10);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0031);
      auto const rel = std::vector<uint32_t>(1, 0xff11);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0032);
      auto const rel = std::vector<uint32_t>(1, 0xff12);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0033);
      auto const rel = std::vector<uint32_t>(1, 0xff13);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0034);
      auto const rel = std::vector<uint32_t>(1, 0xff14);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0035);
      auto const rel = std::vector<uint32_t>(1, 0xff15);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0036);
      auto const rel = std::vector<uint32_t>(1, 0xff16);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0037);
      auto const rel = std::vector<uint32_t>(1, 0xff17);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
  }
  
  TEST(tailoring, ja_standard_000_019)
  {
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0038);
      auto const rel = std::vector<uint32_t>(1, 0xff18);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0039);
      auto const rel = std::vector<uint32_t>(1, 0xff19);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x003a);
      auto const rel = std::vector<uint32_t>(1, 0xff1a);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x003b);
      auto const rel = std::vector<uint32_t>(1, 0xff1b);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x003c);
      auto const rel = std::vector<uint32_t>(1, 0xff1c);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x003d);
      auto const rel = std::vector<uint32_t>(1, 0xff1d);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x003e);
      auto const rel = std::vector<uint32_t>(1, 0xff1e);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x003f);
      auto const rel = std::vector<uint32_t>(1, 0xff1f);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0040);
      auto const rel = std::vector<uint32_t>(1, 0xff20);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0041);
      auto const rel = std::vector<uint32_t>(1, 0xff21);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0042);
      auto const rel = std::vector<uint32_t>(1, 0xff22);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0043);
      auto const rel = std::vector<uint32_t>(1, 0xff23);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0044);
      auto const rel = std::vector<uint32_t>(1, 0xff24);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0045);
      auto const rel = std::vector<uint32_t>(1, 0xff25);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0046);
      auto const rel = std::vector<uint32_t>(1, 0xff26);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0047);
      auto const rel = std::vector<uint32_t>(1, 0xff27);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0048);
      auto const rel = std::vector<uint32_t>(1, 0xff28);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0049);
      auto const rel = std::vector<uint32_t>(1, 0xff29);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x004a);
      auto const rel = std::vector<uint32_t>(1, 0xff2a);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x004b);
      auto const rel = std::vector<uint32_t>(1, 0xff2b);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x004c);
      auto const rel = std::vector<uint32_t>(1, 0xff2c);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x004d);
      auto const rel = std::vector<uint32_t>(1, 0xff2d);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x004e);
      auto const rel = std::vector<uint32_t>(1, 0xff2e);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x004f);
      auto const rel = std::vector<uint32_t>(1, 0xff2f);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0050);
      auto const rel = std::vector<uint32_t>(1, 0xff30);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
      {
      // greater than (or equal to, for =) preceeding cps
      auto const res = std::vector<uint32_t>(1, 0x0051);
      auto const rel = std::vector<uint32_t>(1, 0xff31);
      std::string const res_str = to_string(res);
      std::string const rel_str = to_string(rel);
      auto const res_view = as_utf32(res);
      auto const rel_view = as_utf32(rel);
      EXPECT_EQ(collate(
          res.begin(), res.end(),
          rel.begin(), rel.end(),
          table(), collation_strength::quaternary),
          0);
      EXPECT_EQ(collate(
          res_view.begin(), res_view.end(),
          rel_view.begin(), rel_view.end(),
          table(), collation_strength::quaternary),
          0);
      }
  }
  
  