testing for char conversions

dabrahams · dabrahams · commit 525979afaa7a · 2002-05-07T23:23:32.000Z
[SVN r13735]
diff --git a/test/comprehensive.py b/test/comprehensive.py
@@ -1273,6 +1273,10 @@ def assert_integer_expected(err):
 def run(args = None):
     if args is not None:
         sys.argv = args
+        
+    if hasattr(sys,'setdlopenflags'):
+        sys.setdlopenflags( 6 ) # dl.RTLD_NOW | dl.RTLD_GLOBAL)
+        
     import doctest, comprehensive
     return doctest.testmod(comprehensive)
     
diff --git a/test/m1.cpp b/test/m1.cpp
@@ -10,9 +10,6 @@
 #include <boost/python/module.hpp>
 #include <boost/python/class.hpp>
 #include <boost/python/type_from_python.hpp>
-#include <boost/python/object/value_holder.hpp>
-#include <boost/python/object/pointer_holder.hpp>
-#include <boost/python/object/class.hpp>
 #include <boost/python/copy_const_reference.hpp>
 #include <boost/python/return_value_policy.hpp>
 #include <boost/python/to_python_converter.hpp>
@@ -98,9 +95,7 @@ PyObject* new_simple()
 
 //
 // Declare some wrappers/unwrappers to test the low-level conversion
-// mechanism. See boost/python/converter/source.hpp,target.hpp for a
-// description of how the type parameters to wrapper<> and unwrapper<>
-// are selected.
+// mechanism. 
 //
 using boost::python::to_python_converter;
 
diff --git a/test/test_builtin_converters.cpp b/test/test_builtin_converters.cpp
@@ -25,11 +25,14 @@ struct by_const_reference
     }
 };
 
+char const* rewrap_value_mutable_cstring(char* x) { return x; }
+
 BOOST_PYTHON_MODULE_INIT(builtin_converters)
 {
     boost::python::module("builtin_converters")
         
         .def("rewrap_value_bool", by_value<bool>::rewrap)
+        .def("rewrap_value_char", by_value<char>::rewrap)
         .def("rewrap_value_signed_char", by_value<signed char>::rewrap)
         .def("rewrap_value_unsigned_char", by_value<unsigned char>::rewrap)
         .def("rewrap_value_int", by_value<int>::rewrap)
@@ -47,8 +50,12 @@ BOOST_PYTHON_MODULE_INIT(builtin_converters)
         .def("rewrap_value_string", by_value<std::string>::rewrap)
         .def("rewrap_value_cstring", by_value<char const*>::rewrap)
 
+        // Expose this to illustrate our failings ;-). See test_builtin_converters.py
+        .def("rewrap_value_mutable_cstring", rewrap_value_mutable_cstring)
+
 
         .def("rewrap_const_reference_bool", by_const_reference<bool>::rewrap)
+        .def("rewrap_const_reference_char", by_const_reference<char>::rewrap)
         .def("rewrap_const_reference_signed_char", by_const_reference<signed char>::rewrap)
         .def("rewrap_const_reference_unsigned_char", by_const_reference<unsigned char>::rewrap)
         .def("rewrap_const_reference_int", by_const_reference<int>::rewrap)
diff --git a/test/test_builtin_converters.py b/test/test_builtin_converters.py
@@ -6,6 +6,14 @@
 0
 >>> rewrap_value_bool(33)
 1
+>>> rewrap_value_char('x')
+'x'
+
+  Note that there's currently silent truncation of strings passed to
+  char arguments.
+
+>>> rewrap_value_char('xy')
+'x'
 >>> rewrap_value_signed_char(42)
 42
 >>> rewrap_value_unsigned_char(42)
@@ -42,12 +50,26 @@
 >>> rewrap_value_string('yo, wassup?')
 'yo, wassup?'
 
+  Note that we can currently get a mutable pointer into an immutable
+  Python string:
+  
+>>> rewrap_value_mutable_cstring('hello, world')
+'hello, world'
+
 >>> rewrap_const_reference_bool(None)
 0
 >>> rewrap_const_reference_bool(0)
 0
 >>> rewrap_const_reference_bool('yes')
 1
+>>> rewrap_const_reference_char('x')
+'x'
+
+  Note that there's currently silent truncation of strings passed to
+  char arguments.
+
+>>> rewrap_const_reference_char('xy')
+'x'
 >>> rewrap_const_reference_signed_char(42)
 42
 >>> rewrap_const_reference_unsigned_char(42)

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,14 @@`
`6`	`6`	`0`
`7`	`7`	`>>> rewrap_value_bool(33)`
`8`	`8`	`1`
	`9`	`+>>> rewrap_value_char('x')`
	`10`	`+'x'`
	`11`	`+`
	`12`	`+ Note that there's currently silent truncation of strings passed to`
	`13`	`+ char arguments.`
	`14`	`+`
	`15`	`+>>> rewrap_value_char('xy')`
	`16`	`+'x'`
`9`	`17`	`>>> rewrap_value_signed_char(42)`
`10`	`18`	`42`
`11`	`19`	`>>> rewrap_value_unsigned_char(42)`
`@@ -42,12 +50,26 @@`
`42`	`50`	`>>> rewrap_value_string('yo, wassup?')`
`43`	`51`	`'yo, wassup?'`
`44`	`52`
	`53`	`+ Note that we can currently get a mutable pointer into an immutable`
	`54`	`+ Python string:`
	`55`	`+`
	`56`	`+>>> rewrap_value_mutable_cstring('hello, world')`
	`57`	`+'hello, world'`
	`58`	`+`
`45`	`59`	`>>> rewrap_const_reference_bool(None)`
`46`	`60`	`0`
`47`	`61`	`>>> rewrap_const_reference_bool(0)`
`48`	`62`	`0`
`49`	`63`	`>>> rewrap_const_reference_bool('yes')`
`50`	`64`	`1`
	`65`	`+>>> rewrap_const_reference_char('x')`
	`66`	`+'x'`
	`67`	`+`
	`68`	`+ Note that there's currently silent truncation of strings passed to`
	`69`	`+ char arguments.`
	`70`	`+`
	`71`	`+>>> rewrap_const_reference_char('xy')`
	`72`	`+'x'`
`51`	`73`	`>>> rewrap_const_reference_signed_char(42)`
`52`	`74`	`42`
`53`	`75`	`>>> rewrap_const_reference_unsigned_char(42)`