due to the coarseness of time.time() on Windows.  It looks like an
attempt was made before to fix this, and also removed a wrong comment
explaining that fix.  .pack() used to be documented incorrectly, saying
that stuff before the pack time was packed away.  It's actually the case
that stuff before *or equal to* the pack time is packed away, and that's
a crucial distinction on Windows because time.time() often (usually,
in fact) returns the same value on two successive calls.  The earlier
fix attempt tried to separate observed time.time() values, but did so
before the pack().  That's usually appropriate, but in this test we
really need to make sure that object revisions *after* the pack() get
timestamps distinct from the pack time (else they'll get packed away,
and the test isn't expecting that).

a MappingStorage (which doesn't support versions), so stop trying to
test that combo.

Reduces memory usage during pack by a considerable fraction with
modest 10% slowdown.

We're still missing tests that cover important cases.  Unexecuted code
below:

>>>>>>             if l > len(data) - 8:
>>>>>>                 pos += l
>>>>>>                 break
>>>>>>             s = l + 1
>>>>>>             tl = u64(data[s:s+8])
>>>>>>             if tl < pos:
>>>>>>                 return pos + s + 8

>>>>>>         except:
>>>>>>             if partial and nrec:
>>>>>>                 ofs._status = 'p'
>>>>>>                 ofs.tpc_vote(transaction)
>>>>>>                 ofs.tpc_finish(transaction)
>>>>>>                 if verbose:
>>>>>>                     print 'partial'
                   else:
>>>>>>                 ofs.tpc_abort(transaction)
>>>>>>             print "\n%s: %s\n" % sys.exc_info()[:2]
>>>>>>             if not verbose:
>>>>>>                 progress(prog1)
>>>>>>             pos = scan(file, pos)

Add main() function to do argument processing separate from recover().

version, and likely won't be again.

source tree. This should have taken care of most unused imports
in Zope 3. :)

Covers the case where an object is only reachable in a version at the
pack time.

instead of listcomps.  Added new examples.  Corrected minor mistakes.
Removed the byValue() example and claimed that function is deprecated
(it's almost never used, and it's hard to explain exactly what it does).

Windows will have fsync() starting with 2.2.3.

If asyncore is not running in a separate thread, the client needs to
call poll() to perform the IO necessary for cache verification to
finish.

This allows us to eliminate several calls to sync() in the test suite.

XXX I've got no idea what this is actually supposed to do.  It may be
that clearing the old cache isn't safe, but only if it never was.  If
a non-ghost object is in the cache, it seems that attempts to use it
will go through the wrong cache.

Problem reported by Ulla Theiss and diagnosed by Shane Hathaway.  The
long and short of it is that persistent objects refer to their
connection which refers to its cache which refers to the persistent
objects.  We can't let GC find the cycle because persistent objects
are extension class objects, and, thus, don't participate in GC.

Add an explicit clear() method that removes non-ghost objects from the
ring without going to all the trouble of ghosting them.  At some
point, they'll just get deallocated (which will ghostify them).

A cleared cache has non-ghost objects in the dict that are not in the
ring, so we need to add some checks for whether the object is actually
in the ring.