[C++-sig] Multiple registration safety and unit testing

[David Sankel]

On Sat, Jan 30, 2016 at 7:30 AM, Stefan Seefeld <stefan at seefeld.name> wrote:

> On 29.01.2016 19:19, David Sankel wrote:
> > Hello all,
> >
> > I'd like to allow a class to be registered more than once and wanted
> > to get your opinion if this change would be a good idea.
> >
> > 'boost::python::class_' always adds a class to the current scope and
> > registers it in the global registry. The global registry code
> > (particularly the 'insert' function in 'src/converter/registry.cpp')
> > asserts that the class hasn't been registered already. This, of
> > course, prevents multiple registrations of the same type.
> >
> > There is a use case, though, where multiple registrations of the same
> > type is both necessary and safe. Generally, a c++ component which has
> > a 'class_' call may not know the name of the module it will eventually
> > end up in. It would still be desirable to write a unit test for this
> > component. If we write a unit test and put the 'class_' into some
> > dummy module we run into a problem where other unit tests might call
> > 'class_' in another scope.
> >
> > The safety of multiple 'class_' calls stems from always using the same
> > conversion function. Semantically everything is a-okay.
> >
> > I'm proposing to change the precondition of the
> > 'boost::python::converter::registry::insert' function from:
> >
> >     The behavior is undefined unless the specified 'type_info' object
> >     has not already been registered.
> >
> >
> > to:
> >
> >     The behavior is undefined unless the specified 'type_info' object
> >     has not already been registered with a semantically different
> >     converter
> >
> > Any objections?
>
> Yes. Can you describe your use-case ? And what do you mean exactly by
> "semantically different" ? :-)
>

In one '.cpp' file I have something like:


void addFooAssets()
{
  boost::python::class_< Foo > ( /* etc. */ )
    .def( /* etc */ );
}

// testing code follows.

BOOST_PYTHON_MODULE( fooTest )
{
  addFooAssets();
}

BOOST_AUTO_TEST_CASE( fooAssets ) {
  // import 'fooTest' and check that all is good.
}

In another '.cpp' file, I have something like:

void initBarPackage()
{
  boost::python::object barPackage = boost::python::scope();
  barPackage.attr( "__path__" ) = "bar";

  boost::python::object barFooPackage(
    boost::python::handle<>( boost::python::borrowed(::PyImport_AddModule(
"bar.foo" ) ) ) );
  barPackage.attr( "foo" ) = barFooPackage;

  {
    const boost::python::scope fooScope( barFooPackage );
    addFooAssets();
  }
}

// testing code follows


If I run the unit test for "foo" and that for "bar" in the same test run,
then I'll get 'class_' called twice. It is harmless to call it twice though
since the registration is identical for both calls.

When I say "semantically" the same, I mean that something like the
'to_python' member could point to a different function as long as they "do"
the same thing.

-- David Sankel
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20160201/20b1bfab/attachment.html>