From 5131096b8035891e241e954124a3f048163a188f Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Thu, 18 Jul 2019 19:49:50 +0100 Subject: li_std_wstring test rename to li_std_wstring_inherit This testcase was only run in Ruby and Python and implements an obscure feature where a C++ class inherits from a std::wstring. The li_std_wstring test is left in place to be modified in next commit for more regular wstring testing across all languages. --- Examples/test-suite/li_std_wstring_inherit.i | 113 +++++++++++++++++++++ Examples/test-suite/python/Makefile.in | 2 +- .../python/li_std_wstring_inherit_runme.py | 106 +++++++++++++++++++ Examples/test-suite/ruby/Makefile.in | 2 +- .../ruby/li_std_wstring_inherit_runme.rb | 42 ++++++++ 5 files changed, 263 insertions(+), 2 deletions(-) create mode 100644 Examples/test-suite/li_std_wstring_inherit.i create mode 100644 Examples/test-suite/python/li_std_wstring_inherit_runme.py create mode 100644 Examples/test-suite/ruby/li_std_wstring_inherit_runme.rb diff --git a/Examples/test-suite/li_std_wstring_inherit.i b/Examples/test-suite/li_std_wstring_inherit.i new file mode 100644 index 000000000..547c41a87 --- /dev/null +++ b/Examples/test-suite/li_std_wstring_inherit.i @@ -0,0 +1,113 @@ +%module li_std_wstring_inherit +%include +%include + + +// throw is invalid in C++17 and later, only SWIG to use it +#define TESTCASE_THROW1(T1) throw(T1) +%{ +#define TESTCASE_THROW1(T1) +%} + +%inline %{ + +struct A : std::wstring +{ + A(const std::wstring& s) : std::wstring(s) + { + } +}; + +struct B +{ + B(const std::wstring& s) : cname(0), name(s), a(s) + { + } + + char *cname; + std::wstring name; + A a; + +}; + + +wchar_t test_wcvalue(wchar_t x) { + return x; +} + +const wchar_t* test_ccvalue(const wchar_t* x) { + return x; +} + +wchar_t* test_cvalue(wchar_t* x) { + return x; +} + + +wchar_t* test_wchar_overload() { + return 0; +} + +wchar_t* test_wchar_overload(wchar_t *x) { + return x; +} + +std::wstring test_value(std::wstring x) { + return x; +} + +const std::wstring& test_const_reference(const std::wstring &x) { + return x; +} + +void test_pointer(std::wstring *x) { +} + +std::wstring *test_pointer_out() { + static std::wstring x = L"x"; + return &x; +} + +void test_const_pointer(const std::wstring *x) { +} + +const std::wstring *test_const_pointer_out() { + static std::wstring x = L"x"; + return &x; +} + +void test_reference(std::wstring &x) { +} + +std::wstring& test_reference_out() { + static std::wstring x = L"x"; + return x; +} + +bool test_equal_abc(const std::wstring &s) { + return L"abc" == s; +} + +void test_throw() TESTCASE_THROW1(std::wstring){ + static std::wstring x = L"x"; + + throw x; +} + +const char * non_utf8_c_str() { + return "h\xe9llo"; +} + +size_t size_wstring_size(const std::wstring& s) { + return s.size(); +} + +#ifdef SWIGPYTHON_BUILTIN +bool is_python_builtin() { return true; } +#else +bool is_python_builtin() { return false; } +#endif + +%} + + diff --git a/Examples/test-suite/python/Makefile.in b/Examples/test-suite/python/Makefile.in index 0151f5918..be06f7e51 100644 --- a/Examples/test-suite/python/Makefile.in +++ b/Examples/test-suite/python/Makefile.in @@ -55,7 +55,7 @@ CPP_TEST_CASES += \ li_std_vectora \ li_std_vector_extra \ li_std_wstream \ - li_std_wstring \ + li_std_wstring_inherit \ primitive_types \ python_abstractbase \ python_append \ diff --git a/Examples/test-suite/python/li_std_wstring_inherit_runme.py b/Examples/test-suite/python/li_std_wstring_inherit_runme.py new file mode 100644 index 000000000..0ede5b16b --- /dev/null +++ b/Examples/test-suite/python/li_std_wstring_inherit_runme.py @@ -0,0 +1,106 @@ +import li_std_wstring_inherit +import sys + +x = u"h" + +if li_std_wstring_inherit.test_wcvalue(x) != x: + print li_std_wstring_inherit.test_wcvalue(x) + raise RuntimeError("bad string mapping") + +x = u"hello" +if li_std_wstring_inherit.test_ccvalue(x) != x: + raise RuntimeError("bad string mapping") + +if li_std_wstring_inherit.test_cvalue(x) != x: + raise RuntimeError("bad string mapping") + +if li_std_wstring_inherit.test_wchar_overload(x) != x: + raise RuntimeError("bad string mapping") + +if li_std_wstring_inherit.test_wchar_overload("not unicode") != "not unicode": + raise RuntimeError("bad string mapping") + +if li_std_wstring_inherit.test_value(x) != x: + print x, li_std_wstring_inherit.test_value(x) + raise RuntimeError("bad string mapping") + +if li_std_wstring_inherit.test_const_reference(x) != x: + raise RuntimeError("bad string mapping") + + +s = li_std_wstring_inherit.wstring(u"he") +s = s + u"llo" + +if s != x: + print s, x + raise RuntimeError("bad string mapping") + +if s[1:4] != x[1:4]: + raise RuntimeError("bad string mapping") + +if li_std_wstring_inherit.test_value(s) != x: + raise RuntimeError("bad string mapping") + +if li_std_wstring_inherit.test_const_reference(s) != x: + raise RuntimeError("bad string mapping") + +a = li_std_wstring_inherit.A(s) + +if li_std_wstring_inherit.test_value(a) != x: + raise RuntimeError("bad string mapping") + +if li_std_wstring_inherit.test_const_reference(a) != x: + raise RuntimeError("bad string mapping") + +b = li_std_wstring_inherit.wstring(" world") + +if a + b != "hello world": + raise RuntimeError("bad string mapping") + +if a + " world" != "hello world": + raise RuntimeError("bad string mapping") + +# This is expected to fail if -builtin is used +# Reverse operators not supported in builtin types +if not li_std_wstring_inherit.is_python_builtin(): + if "hello" + b != "hello world": + raise RuntimeError("bad string mapping") + + c = "hello" + b + if c.find_last_of("l") != 9: + raise RuntimeError("bad string mapping") + +s = "hello world" + +b = li_std_wstring_inherit.B("hi") + +b.name = li_std_wstring_inherit.wstring(u"hello") +if b.name != "hello": + raise RuntimeError("bad string mapping") + + +b.a = li_std_wstring_inherit.A("hello") +if b.a != u"hello": + raise RuntimeError("bad string mapping") + +# Byte strings only converted in Python 2 +if sys.version_info[0:2] < (3, 0): + x = b"hello there" + if li_std_wstring_inherit.test_value(x) != x: + raise RuntimeError("bad string mapping") + +# Invalid utf-8 in a byte string fails in all versions +x = b"h\xe9llo" +try: + li_std_wstring_inherit.test_value(x) + raise RuntimeError("TypeError not thrown") +except TypeError: + pass + +# Check surrogateescape +if sys.version_info[0:2] > (3, 1): + x = u"h\udce9llo" # surrogate escaped representation of C char*: "h\xe9llo" + if li_std_wstring_inherit.non_utf8_c_str() != x: + raise RuntimeError("surrogateescape not working") + if li_std_wstring_inherit.size_wstring(x) != 5 and len(x) != 5: + raise RuntimeError("Unexpected length") diff --git a/Examples/test-suite/ruby/Makefile.in b/Examples/test-suite/ruby/Makefile.in index 6393026a4..d75cdb058 100644 --- a/Examples/test-suite/ruby/Makefile.in +++ b/Examples/test-suite/ruby/Makefile.in @@ -20,7 +20,7 @@ CPP_TEST_CASES = \ li_std_queue \ li_std_set \ li_std_stack \ - li_std_wstring \ + li_std_wstring_inherit \ primitive_types \ ruby_alias_method \ ruby_keywords \ diff --git a/Examples/test-suite/ruby/li_std_wstring_inherit_runme.rb b/Examples/test-suite/ruby/li_std_wstring_inherit_runme.rb new file mode 100644 index 000000000..4a66e9fcf --- /dev/null +++ b/Examples/test-suite/ruby/li_std_wstring_inherit_runme.rb @@ -0,0 +1,42 @@ +# -*- coding: utf-8 -*- +require 'swig_assert' +require 'li_std_wstring_inherit' + +x = "abc" +swig_assert_equal("Li_std_wstring_inherit.test_wchar_overload(x)", "x", binding) +swig_assert_equal("Li_std_wstring_inherit.test_ccvalue(x)", "x", binding) +swig_assert_equal("Li_std_wstring_inherit.test_value(Li_std_wstring_inherit::Wstring.new(x))", "x", binding) + +swig_assert_equal("Li_std_wstring_inherit.test_wchar_overload()", "nil", binding) + +swig_assert_equal("Li_std_wstring_inherit.test_pointer(Li_std_wstring_inherit::Wstring.new(x))", "nil", binding) +swig_assert_equal("Li_std_wstring_inherit.test_const_pointer(Li_std_wstring_inherit::Wstring.new(x))", "nil", binding) +swig_assert_equal("Li_std_wstring_inherit.test_const_pointer(Li_std_wstring_inherit::Wstring.new(x))", "nil", binding) +swig_assert_equal("Li_std_wstring_inherit.test_reference(Li_std_wstring_inherit::Wstring.new(x))", "nil", binding) + +x = "y" +swig_assert_equal("Li_std_wstring_inherit.test_value(x)", "x", binding) +a = Li_std_wstring_inherit::A.new(x) +swig_assert_equal("Li_std_wstring_inherit.test_value(a)", "x", binding) + +x = "hello" +swig_assert_equal("Li_std_wstring_inherit.test_const_reference(x)", "x", binding) + + +swig_assert_equal("Li_std_wstring_inherit.test_pointer_out", "'x'", binding) +swig_assert_equal("Li_std_wstring_inherit.test_const_pointer_out", "'x'", binding) +swig_assert_equal("Li_std_wstring_inherit.test_reference_out()", "'x'", binding) + +s = "abc" +swig_assert("Li_std_wstring_inherit.test_equal_abc(s)", binding) + +begin + Li_std_wstring_inherit.test_throw +rescue RuntimeError => e + swig_assert_equal("e.message", "'x'", binding) +end + +x = "abc\0def" +swig_assert_equal("Li_std_wstring_inherit.test_value(x)", "x", binding) +swig_assert_equal("Li_std_wstring_inherit.test_ccvalue(x)", '"abc"', binding) +swig_assert_equal("Li_std_wstring_inherit.test_wchar_overload(x)", '"abc"', binding) -- cgit v1.2.3