Remove shebang line from manifest.py; not self-runnable
test.py is python-2/3-agnostic
Fix StringIO for python3
s/assertEquals/assertEqual/; python3 warns about deprecation
Small script for running test suite under both python2 and python3
python3 print is a function
python3 does not have dict.iteritems
python3 generators does not support .next(); use next(gen) instead
Remove extraneous tuple()
map()/filter() return values are no longer lists in python3

In python3, the return values from map() and filter() are special
map/filter objects, and not lists, as in python2. This means that in
order to compare a return value from map() to an expected list, we first
need to "cast" map()'s return to a list, at which point, the whole
expression is probably more readable as a list comprehension, anyway.
Likewise, for filter(), since its return value is no longer a list,
we cannot directly coerce it to boolean in a comparison to check if
the filtered sequence is non-empty. Here, we instead rewrite the
filter() expression to a generator expression, typically wrapped in
any(...) to express the same behavior in a python3-compatible manner.
Coerce dict.keys() return value to a list

In python3, dict.keys() no longer returns a list, so when we want to
compare it to a list of expected values, we need to "cast" it, typically
by using list(). In this case, however, the surrounding pattern (when the
expected list consists of more than one element, we need to _sort_ the
return value from .keys() in order to make it comparable. Therefore, we
use the same sorted(foo.keys()) pattern (which - like list() - returns a
proper list), even when there is only a single expected element.
Run test suite under all available python versions
Refactor Test_Manifest_parse to reflect that Manifest is a dict.

Instead of using dict methods to query the parsed manifest for expected
values, compare it directly against the expected dict.
Minor rename to improve clarity

It is not obvious that test_utils.Manifest_from_tar() actually unpacks
the tar file into a temp dir, and then performs a regular
Manifest.from_walk() in that temp dir. Make this clearer by renaming the
function to test_utils.Manifest_from_walking_unpacked_tar().
Test_Manifest_from_walk: Compare against expected dict, not output of .write()

Use the fact that Manifest is a dict, to compare the result of .from_walk()
directly against an expected dict, instead of calling .write() and comparing
the resulting string against the expected string.

This enables us to remove the StringIO dependency from this test.
Exit immediately on failing tests
Avoid mutable default arguments
Misc. minor typofixes, rephrasing and doc updates
Add Manifest.from_tar() to create manifests from tar archives

This allows us to directly construct a manifest mapping the contents of a
tar archive, without having to unpack the tar archive into a directory
structure, and then walking that structure.

Include test cases demonstrating correct functionality.

There is an unresolved corner case on python2.6, where an empty file will
incorrectly be interpreted as a proper (but empty) tar(.gz) archive; the
result is that Manifest.from_tar() returns an empty manifest instead of
raising an exception. This is ultimately a bug in python's tarfile
module, but we may want to consider adding a workaround if this (i.e.
feeding empty files to Manifest.from_tar() and expecting an exception)
turns out to be needed in practice.
Remove WIP. Apparently we don't need it (yet)...