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.

in a version, we fall back to non-version data.

Undo wasn't tested properly. The tests didn't get the undo ids
from the transaction log.

recognize other valid failure modes.

object hasn't been modified in a version, we fall back to non-version
data.

There are a couple of places where the spec was unclear and I punted
for now.

To do this, I had to change the temprary index to be a mapping
object (dictionary) rather than a sequence (list).

the fact that tpc_vote and tpc_finish can be called extra times.

Also added code to same test to undo the transaction that undid
multiple transaction to exercise bug found in FileStorage.

We now pass the tests we test. We still have to add the version tests,
which we were failing before.

undone and then redone, if the underlying storage supports
transactionalUndo.

Also fixed a bug in an unused method. The bug causes warnings in
Python 2.1.

Unfortutely, tpc_finish didn't handle this case correctly.

committed state in. This is needed wheh the "committed" state,
um, hasn't been committed yet, such as when you are undoing
multiple transactions transactionally.