storage id

The cdata and cver had been swapped, causing all undos to fail,
because the version was compared to a pickle.

checkBuggyResolve2() -- _p_resolveConflict takes too few args
checkUndoConflictResolution() -- make sure conflict resolution is
     invoked properly during transactional undo
checkUndoUnresolvable() -- make sure transactional undo can cope with
     failed conflict resolution

Add new tests for conflict resolution.

The old blanket try-except for conflict resolution was hiding some
bugs caused by the pickles used in the test suite.  The conflict
resolution code imposes some restrictions on the format of pickles.
Basically, the conflict resolution requires that the storage API only
accept a pickles that constructed according to the ZODB rules.

XXX This new restriction sounds unfortunate, but it would require a
substantial change to conflict resolution to remove it.

The key changes to the test suite are to store only persistent objects
and to format the pickles using the standard ZODB format.  All tests
now use ZODB.tests.MinPO.MinPO instances for data.  The pickling is
down with zodb_pickle() and zodb_unpickle() defined in
StorageTestBase.

Add conflict resolution tests to testFileStorage.  (They pass.)

The value of _loadBack() -- a pickle and a serialno -- was being
passed to tryToResolveConflict() where only a pickle was expected.

XXX _loadBack() can raise KeyError, but this wasn't handled by the
code.  Turn into UndoError() for now.

exactly one exception, ConflictError

Remove klass._p_resolveConflict line, because it's only apparent
purpose was to raise an AttributeError that was caught by the blanket
try-except.  Instead, let the later code, which actually uses
_p_resolveConflict() catch the AttributeError and return 0.

Add -t n flag to specify number of concurrent threads
Add -U flag to specify a Unix domain socket

transaction.

The ZEO version of the storage API returns serial numbers for stores
in a different way.  These changes are the minimum needed to make the
tests handle the ZEO way of doing things; I assume they still work
with non-ZEO storage.

XXX These tests should be cleaned up to all use
_multi_obj_transactions(), which should probably get a different name,
like _domultistore().

All tests except checkLen() pass.

    at least) seems to imply that they are optional.
Fix typo in long attribute name.

             Transaction instance.

tpc_finish(): Ignore the arguments other than id.  They were handled
              in the tpc_begin().

checkPackAllRevisions(): Create an object and store three different
revisions of the object.  Before packing, check to make sure all three
revisions can be loaded.  After packing, make sure all revisions are
gone (since they were not referenced by the root object, they are
garbage).

checkPackJustOldRevisions(): Same as above, but this time create a
root object and a link from the root object to the persistent object.
Then store three different revisions of the persistent object and make
sure all three revisions can be loaded.  After packing, make sure the
first two revisions are gone, but that the third revision (and the
root object) can be loaded.

Other changes:

- Add a ZERO global

- Add a Root class which does /not/ have a getoid() method (so its
  state will be pickled as normal, but attributes that point to
  `persistent' objects will be serialized as persistent ids).

- dumps(): In getpersid(), return None if the object has no getoid()
  method.  This ensures that the root object will get pickled
  correctly as described above.

- _newobj(), _makeloader(): Move these into a common base class called
  PackableStorageBase.  This base class also maintains the cache of
  persistent ids to Object instances, for unpickling.

- PackableStorage is the derived class that contains the actual tests.

dumps(), makeloader(): Take these out of the PackableStorage class,
and keep them even though they aren't currently used.

checkOldRevisionPacked(): Removed -- it's too complicated as a first
test.

checkSimplePack(): New pack() checker; it creates three revisions of
the same object, then attempts to pack to `now'.  Then it makes sure
that revisions 1 and 2 of the object are gone, but that revision 3
(the current revision) still exists.  Full passes this test, but
FileStorage fails. :(

pickling

suppresses the pickling of the data.

_dostoreNP(): A shortcut for _dostore(..., already_pickled=1)

complete or correct yet (Jim, feel free to start filing it in! :)

the cache will return data from version X whenever versioned data is
requested, regardless of whether the version in question is X.

the undo log.

tpc_finish(); i.e. it acquires the lock, checks the argument, and then
calls self._vote().  Note that the transaction passed to tpc_vote()
isn't passed to self._vote(), since I don't what would be useful.

BaseStorage._vote(): current no-op.

remaining problem with full Berkeley storage's transactionalUndo().
Specifically:

    tid 1: create object 1
    tid 2: modify object 1
    tid 3: undo tid 2
    ----------------------
    tid 4: undo tid 1 (1st alternative universe)
    ----------------------
    tid 4: undo tid 3 (2nd alternative universe)

The new tests are checkUndoCreationBranch1() and
checkUndoCreationBranch2(), corresponding to alternative universes 1
and 2, respectively.  Full storage currently fails a.u. #2.
FileStorage passes.

versionEmpty.