Many more remain.

Since now we need to pass an extra argument to loads() and Unpickler(),
but only on Python 3, the old way of ``from ZODB._compat import pickle``
no longer pays out, and I had to import the names directly.

The only remaining test failures are due to changed pickle sizes.  I've
discovered two reasons for that so far:

  1) Python 3 pickles 'native strings' as BINUNICODE, Python 2 pickles
     'native strings' as SHORT_BINSTRING, which is 3 bytes shorter.

  2) Python 3 and also the 'pickle' module Python 2 pickles tuples like
     (UserDefinedClass, ) with an extra BINPUT opcode at the end,
     compared to 'cPickle' in Python 2 when given the same tuple:

        Python 2.7.3 (default, Sep 26 2012, 21:51:14)
        [GCC 4.7.2] on linux2
        Type "help", "copyright", "credits" or "license" for more information.
        >>> import pickle, cPickle
        >>> class MyClass(object): pass
        ...
        >>> len(pickle.dumps((MyClass, None), 1))
        26
        >>> len(cPickle.dumps((MyClass, None), 1))
        24

The plan is to switch to zodbpickle instead of the builtin Python 3
pickle, then use encoding=bytes from http://bugs.python.org/issue6784
and fix the class-in-tuple encoding to match Python 2's cPickle.

This test wants to rely on OIDs that are assigned to various objects.
OIDs are assigned by Pickler.persistent_id(), which gets called during
graph traversal in a nonspecific order (courtesy randomized hashes in
Python 3), so if we want to be sure to have the right OIDs assigned to
the right objects, we need to call connection.add() manually or commit
after adding every object.

This fixes nondeterministic failures in
doctest_lp485456_setattr_in_setstate_doesnt_cause_multiple_stores

Because our test suite triggers that 'RuntimeError: dictionary changed
size during iteration' error sporadically.

Stdlib's _compat_pickle is a big help here, but I've an uneasy feeling
it's not supposed to be a public API.

Problem: in Python 2 object lives in sys.modules['__builtin__'].  In
Python 3 it lives in sys.modules['builtins'].  When we pickle object in
Python 2 and try to load it in Python 3, we end up getting a Broken
object placeholder because sys.modules['__builtin__'] is AWOL.

I'm not sure how persistentclass.txt manages to reproduce that purely in
Python 3, but that's what the new assertion failure I added reports.

Oh, I know: old pickle protocol!

    Python 3.3.0 (default, Sep 29 2012, 17:14:58)
    [GCC 4.7.2] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import pickle
    >>> pickle.dumps(object)
    b'\x80\x03cbuiltins\nobject\nq\x00.'
    >>> pickle.dumps(object, 1)
    b'c__builtin__\nobject\nq\x00.'
    >>> pickle.loads(_)
    <class 'object'>

We need to find the mapping layer that handles __builtin__ in Python
3.3's pickle and make sure our own ZODB.broken.find_global can do the
same.

In Python 2 str(SomeClass) returns "modulename.ClassName".

In Python 3 str(SomeClass) returns "<class 'modulename.ClassName'>".

We want the former.

Python 3 really wants rich comparison operators

In Python 3 object.__hash__ raises TypeError, so we need an explicit
override if we want hashability.

It seems that OIDs are assigned in random order (dictionary iteration
order perhaps), and the test made assumptions.  Add an extra
transaction.commit() between object addition to fix OID assignment
order.

(To distinguish them from real functions that actually do something when
called.)

Next: the hexify() function needs to handle bytestrings on Py3 and
regular strings on Py2.

Apparently the with statement leaves a local variable pointing to the
BlobFile object, which holds a reference to the blog and prevents it
from being garbage collected.

largely due to:

* Different pickle size in Python
  (even for protocol 1, where new padding is added as far as I can tell.)

* Weak references do not seem to work correctly.

* When all tests are run, committing transactions fails. Probably some
  tests are not cleaning up enough after themselves.

The biggest issue remaining at this point is the fork of Python 3.3's
pickle to properly load Python 2 binary strings and adding back
``noload()`` to the unpickler.

failures left.

Thanks to Martin v. Loewis for having done some of the initial lifting
for a DZUG talk. I used a lot of his changes from this diff:

http://www.dcl.hpi.uni-potsdam.de/home/loewis/zodb/ZODB.diff

Applied all changes manually to make sure I do understand them and that
they are correct.

As always 90% of the work is to catch all places where we want to deal
with bytes instead of strings.

- Denominate files to indicate ReST.

- Drop .bzrignore.

- Add MANIFEST.in FBO users w/o setuptools_git.