* compare handlers:

  hash/array slice

  can

* warn about noclass in a circular structure... dunno now...

* add tests for Sets of various things

* rename diagnostics to diag_full

* add Data::Dumper features, including dumping with errors highlighted

* get any to generate diags for each part and splurge all if none match

* add tests for useclass

* will set call methods an unknown number of times? Isn't the result cached

already?

* cache method calls so that multiple call won't make a difference. This

will only work if they don't also look inside the object

* fix the compare() system so I can use descend

* protect against dieing in slices

* use sets in all and any's compare method

* add not()

* give a way to name tests so that they can be reused

* use set/bag in set/bag compare()

* add a holder like Code::Perl's

* add variables so { key1 => var("this"), key2 => var("this")} makes sure

that $h->{key1} equals $h->{key2}. Make sure they are implemented using

local for scoping (no! otherwise the above will break). Maybe setvar and

cmpvar

* add < > lt gt

* add label() to allow labelling of sections

* fix add for sets so that ignore dupes doesn't kick in too early

* add deep() explicitly request deep - why?

* clean up quoting

* fix Test::Deep::Set::add - I'll do that with the set cleanup

* worry about what happens when a temp array ref gets the address of a

previous temp array ref and we check them in the cache. Do we need a class

for temps?

* add more tests for reftype

* add glob stuff

* test the compare methods

* make String check definedness 

* make regexprefs work by using some more general overload mechanism

* when failing a number due to strictness we should give different diags but

diags aren't flexible enough yet

* add docs for comparisons

* for circular refs, we are not looking for simulations but for graph

isomorphisms (or possibly a class of homomorphisms, that preserve the

distinctness of containers). We need a cache that can answer "assuming a=b,

are these two cache-equal?" and can keep track of dependencies. Shouldn't be

too hard to make it possible but making it fast could be a problem. Would

naming things help? Is this getting prological?

* use Class::ISA for ISA stuff, especially under 5.6.0

* get methods to emit better diags for non existant methods, including class

of object

* all() doesn't need to tell you part n, what matters is the test that was

going on. Also any() should diags for each failure so they can be displayed

if nothing passes

* get set using some standard subtests

* split String into String and is_eq or streq

* make an iterator comparator that can run over an array or whatever use it

for Array, ArrayEach, ArrayAny

* need to differentiate between UNIVERSAL::isa and ->isa

* beef up the reftype checking for ScalarRef so bad $self->{val} won't break

it

* think about merging test_class and test_reftype into 1

* fix compare for Ignore, All and Code

* glob comparison

* code comparison using B::Deparse? sounds like a bad idea due to private

data in closures

* add eval at the outler layer to catch all nasties and report them along

with the data path at which they occured