Support different std containers, support different basic types

1 files changed, 71 insertions, 12 deletions

diff --git a/src/test-unicode.cpp b/src/test-unicode.cpp
index 5f5ebbf..fbd4749 100644
--- a/src/test-unicode.cpp
+++ b/src/test-unicode.cpp
@@ -5,9 +5,12 @@
 #include <boost/test/data/monomorphic.hpp>
 #include <boost/test/data/test_case.hpp>
 
+#include <array>
 #include <chrono>
+#include <deque>
 #include <exception>
 #include <limits>
+#include <list>
 #include <random>
 #include <string>
 #include <tuple>
@@ -98,14 +101,14 @@ void test_utf_to_utf(std::tuple<Ts...>& t)
 
  // test base type interface
  To result { unicode::convert<typename From::value_type, typename To::value_type>(std::get<i>(t)) };
+ BOOST_CHECK_MESSAGE(std::get<j>(t) == result, "Base: From " << typeid(typename From::value_type).name() << "(" << i << ", " << std::get<i>(t) << ") to " << typeid(typename To::value_type).name() << "(" << j << ", " << std::get<j>(t) << "), got " << result);
 
- BOOST_CHECK_MESSAGE(std::get<j>(t) == result, "Base: From " << typeid(From).name() << "(" << i << ", " << std::get<i>(t) << ") to " << typeid(To).name() << "(" << j << ", " << std::get<j>(t) << "), got " << result);
+ // test container interface
+ result = unicode::convert<From, To>(std::get<i>(t));
+ BOOST_CHECK_MESSAGE(std::get<j>(t) == result, "Container: From " << typeid(From).name() << "(" << i << ", " << std::get<i>(t) << ") to " << typeid(To).name() << "(" << j << ", " << std::get<j>(t) << "), got " << result);
 
- //std::cout << std::to_string(std::tuple_size<typename std::remove_reference<decltype(t)>::type>::value) << "," << std::to_string(i) << "," << std::to_string(j) << std::endl;
- 
  // test facet interface
  result = unicode::convert<typename unicode::Encoding<typename From::value_type>::Facet, typename unicode::Encoding<typename To::value_type>::Facet>(std::get<i>(t));
-
  BOOST_CHECK_MESSAGE(std::get<j>(t) == result, "Facet: From " << typeid(From).name() << "(" << i << ", " << std::get<i>(t) << ") to " << typeid(To).name() << "(" << j << ", " << std::get<j>(t) << "), got " << result);
  
  // iterate over other combinations
@@ -132,6 +135,10 @@ void test_is_valid_utf(std::tuple<Ts...>& t)
 
  // test via basic type
  bool result { unicode::is_valid_utf<typename T::value_type>(std::get<i>(t)) };
+ BOOST_CHECK_MESSAGE(result == true, "is_valid_utf w/ " << typeid(typename T::value_type).name() << "(" << i << ", " << std::get<i>(t) << "), got " << result);
+
+ // test via container type
+ result = unicode::is_valid_utf<T>(std::get<i>(t));
  BOOST_CHECK_MESSAGE(result == true, "is_valid_utf w/ " << typeid(T).name() << "(" << i << ", " << std::get<i>(t) << "), got " << result);
 
  // test via Facet
@@ -158,7 +165,17 @@ void test_utf_to_utf_failure(std::basic_string<From>& s)
  // via base type
  try {
   (void) unicode::convert<From,To>(s);
-  BOOST_ERROR("Base: Expected exception at index: " << index << ", " << typeid(From).name() << " -> " << typeid(To).name());
+  BOOST_ERROR("Base type: Expected exception at index: " << index << ", " << typeid(From).name() << " -> " << typeid(To).name());
+ } catch (const std::invalid_argument&) {
+  // OK: this is an expected exception for convert() on bad input
+ } catch (const std::exception& ex) {
+  BOOST_ERROR("Unexpected error on convert(): " << ex.what());
+ };
+
+ // via container
+ try {
+  (void) unicode::convert<typename unicode::Encoding<From>::Facet::string_type, typename unicode::Encoding<To>::Facet::string_type>(s);
+  BOOST_ERROR("Container type: Expected exception at index: " << index << ", " << typeid(From).name() << " -> " << typeid(To).name());
  } catch (const std::invalid_argument&) {
   // OK: this is an expected exception for convert() on bad input
  } catch (const std::exception& ex) {
@@ -198,6 +215,8 @@ void test_is_valid_utf_failure(std::basic_string<T>& s)
 {
  BOOST_CHECK_MESSAGE(unicode::is_valid_utf<T>(s) == false, "Expected bad UTF at index: " << index << ", " << typeid(T).name());
  
+ BOOST_CHECK_MESSAGE(unicode::is_valid_utf<typename std::basic_string<T>>(s) == false, "Expected bad UTF at index: " << index << ", " << typeid(T).name());
+ 
  BOOST_CHECK_MESSAGE(unicode::is_valid_utf<typename unicode::Encoding<T>::Facet>(s) == false, "Expected bad UTF at index: " << index << ", " << typeid(typename unicode::Encoding<T>::Facet).name());
 
  // iterate over remaining types 
@@ -275,6 +294,21 @@ void test_random(random_context& rc, size_t length)
   BOOST_ERROR("Unexpected error on convert(): " << ex.what());
  }
 
+ // container type interface
+ try {
+  To result{unicode::convert<From, To>(r)};
+
+  if (r.empty()) {
+   BOOST_CHECK(result.empty());
+  } else {
+   BOOST_CHECK(!result.empty());
+  }
+ } catch (const std::invalid_argument&) {
+  // OK: this is an expected exception for convert() on bad input
+ } catch (const std::exception& ex) {
+  BOOST_ERROR("Unexpected error on convert(): " << ex.what());
+ }
+
  // facet interface
  try {
   To result{unicode::convert<typename unicode::Encoding<typename From::value_type>::Facet,typename unicode::Encoding<typename To::value_type>::Facet>(r)};
@@ -331,7 +365,7 @@ BOOST_AUTO_TEST_CASE(convert)
  
  BOOST_CHECK((unicode::convert<unicode::UTF_8,unicode::UTF_16>("abc")) == std::u16string{u"abc"});
  BOOST_CHECK((unicode::convert<unicode::UTF_32,unicode::UTF_16>(U"abc")) == std::u16string{u"abc"});
- 
+
  BOOST_CHECK((unicode::convert<utf8_t,char16_t>("abc")) == std::u16string{u"abc"});
  BOOST_CHECK((unicode::convert<char32_t,char16_t>(U"abc")) == std::u16string{u"abc"});
 
@@ -354,7 +388,37 @@ BOOST_AUTO_TEST_CASE(convert)
  
  BOOST_CHECK((unicode::convert<std::string, std::wstring>(std::string{"äöü"})) == std::wstring{L"äöü"});
  
- //BOOST_CHECK((unicode::convert<std::vector<char>, std::vector<wchar_t>>(std::vector<char>{})) == std::vector<wchar_t>{});
+ BOOST_CHECK((unicode::convert<std::vector<char>, std::vector<wchar_t>>(std::vector<char>{})) == std::vector<wchar_t>{});
+ BOOST_CHECK((unicode::convert<std::vector<char>, std::vector<wchar_t>>(std::vector<char>{'\xc3', '\xa4', '\xc3', '\xb6', '\xc3', '\xbc'})) == (std::vector<wchar_t>{L'ä', L'ö', L'ü'}));
+ 
+ // deque
+ BOOST_CHECK((unicode::convert<std::deque<char>, std::deque<wchar_t>>(std::deque<char>{})) == std::deque<wchar_t>{});
+ BOOST_CHECK((unicode::convert<std::deque<char>, std::deque<wchar_t>>(std::deque<char>{'\xc3', '\xa4', '\xc3', '\xb6', '\xc3', '\xbc'})) == (std::deque<wchar_t>{L'ä', L'ö', L'ü'}));
+ 
+ // deque with uint8_t, uint16_t
+ BOOST_CHECK((unicode::convert<std::deque<uint8_t>, std::deque<uint16_t>>(std::deque<uint8_t>{})) == std::deque<uint16_t>{});
+ BOOST_CHECK((unicode::convert<std::deque<uint8_t>, std::deque<uint16_t>>(std::deque<uint8_t>{0xc3, 0xa4, 0xc3, 0xb6, 0xc3, 0xbc})) == (std::deque<uint16_t>{L'ä', L'ö', L'ü'}));
+ 
+ // deque with int8_t, int16_t
+ BOOST_CHECK((unicode::convert<std::deque<int8_t>, std::deque<int16_t>>(std::deque<int8_t>{
+                                                                        static_cast<int8_t>(0xc3),
+                                                                        static_cast<int8_t>(0xa4),
+                                                                        static_cast<int8_t>(0xc3),
+                                                                        static_cast<int8_t>(0xb6),
+                                                                        static_cast<int8_t>(0xc3),
+                                                                        static_cast<int8_t>(0xbc)})) == (std::deque<int16_t>{L'ä', L'ö', L'ü'}));
+ 
+ // list
+ BOOST_CHECK((unicode::convert<std::list<uint8_t>, std::list<uint16_t>>(std::list<uint8_t>{})) == std::list<uint16_t>{});
+ BOOST_CHECK((unicode::convert<std::list<uint8_t>, std::list<uint16_t>>(std::list<uint8_t>{0xc3, 0xa4, 0xc3, 0xb6, 0xc3, 0xbc})) == (std::list<uint16_t>{L'ä', L'ö', L'ü'}));
+
+ // list -> deque
+ BOOST_CHECK((unicode::convert<std::list<uint8_t>, std::deque<uint16_t>>(std::list<uint8_t>{})) == std::deque<uint16_t>{});
+ BOOST_CHECK((unicode::convert<std::list<uint8_t>, std::deque<uint16_t>>(std::list<uint8_t>{0xc3, 0xa4, 0xc3, 0xb6, 0xc3, 0xbc})) == (std::deque<uint16_t>{L'ä', L'ö', L'ü'}));
+ 
+ // array
+ BOOST_CHECK((unicode::convert<std::array<uint8_t, 0>, std::list<uint16_t>>(std::array<uint8_t, 0>{})) == std::list<uint16_t>{});
+ BOOST_CHECK((unicode::convert<std::array<uint8_t, 6>, std::list<uint16_t>>(std::array<uint8_t, 6>{0xc3, 0xa4, 0xc3, 0xb6, 0xc3, 0xbc})) == (std::list<uint16_t>{L'ä', L'ö', L'ü'}));
 }
 
 BOOST_AUTO_TEST_CASE(is_valid_utf)
@@ -376,8 +440,3 @@ BOOST_AUTO_TEST_CASE(string_u8string)
  
  BOOST_CHECK(a == std::string{"\xc3\xa4"});
 }
-
-// TODO:
-//
-// string, vector?
-// uint8_t, uint16_t, uint32_t?