t/Data-MultiValuedHash.t

# Before `make install' is performed this script should be runnable with
# `make test'. After `make install' it should work as `perl t/Data-MultiValuedHash.t'

######################### We start with some black magic to print on failure.

# Change 1..1 below to 1..last_test_to_print .
# (It may become useful if the test is moved to ./t subdirectory.)

BEGIN { $| = 1; print "1..221\n"; }
END {print "not ok 1\n" unless $loaded;}
use Data::MultiValuedHash 1.081;
$loaded = 1;
print "ok 1\n";
use strict;
use warnings;

# Set this to 1 to see complete result text for each test
my $verbose = shift( @ARGV ) ? 1 : 0;  # set from command line

######################### End of black magic.

# Insert your test code below (better if it prints "ok 13"
# (correspondingly "not ok 13") depending on the success of chunk 13
# of the test code):

######################################################################
# Here are some utility methods:

my $test_num = 1;  # same as the first test, above

sub result {
	$test_num++;
	my ($worked, $detail) = @_;
	$verbose or 
		$detail = substr( $detail, 0, 50 ).
		(length( $detail ) > 47 ? "..." : "");	
	print "@{[$worked ? '' : 'not ']}ok $test_num $detail\n";
}

sub message {
	my ($detail) = @_;
	print "-- $detail\n";
}

sub vis {
	my ($str) = @_;
	$str =~ s/\n/\\n/g;  # make newlines visible
	$str =~ s/\t/\\t/g;  # make tabs visible
	return( $str );
}

sub serialize {
	my ($input,$is_key) = @_;
	return( join( '', 
		ref($input) eq 'HASH' ? 
			( '{ ', ( map { 
				( serialize( $_, 1 ), serialize( $input->{$_} ) ) 
			} sort keys %{$input} ), '}, ' ) 
		: ref($input) eq 'ARRAY' ? 
			( '[ ', ( map { 
				( serialize( $_ ) ) 
			} @{$input} ), '], ' ) 
		: defined($input) ?
			"'$input'".($is_key ? ' => ' : ', ')
		: "undef".($is_key ? ' => ' : ', ')
	) );
}

######################################################################

message( "START TESTING Data::MultiValuedHash" );

######################################################################
# testing new(), initialize(), and clone()

{
	message( "testing new(), initialize(), and clone()" );

	my ($did, $should);

	# make empty, case-sensitive (norm)

	my $mvh1 = Data::MultiValuedHash->new();  
	result( UNIVERSAL::isa( $mvh1, "Data::MultiValuedHash" ), 
		"mvh1 = new() ret MVH obj" );

	$did = $mvh1->ignores_case();
	result( $did == 0, "on init mvh1->ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh1->fetch_all() ) );
	$should = "{ }, ";
	result( $did eq $should, "on init mvh1->fetch_all() returns '$did'" );

	# make empty, case-insensitive

	my $mvh2 = Data::MultiValuedHash->new( 1 );  
	result( UNIVERSAL::isa( $mvh2, "Data::MultiValuedHash" ), 
		"mvh2 = new( 1 ) ret MVH obj" );

	$did = $mvh2->ignores_case();
	result( $did == 1, "on init mvh2->ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh2->fetch_all() ) );
	$should = "{ }, ";
	result( $did eq $should, "on init mvh2->fetch_all() returns '$did'" );

	# make new with initial values, case-sensitive keys

	my $mvh3 = Data::MultiValuedHash->new( 0, {
		Name => 'John',
		age => 17,
		color => 'green',
		Siblings => ['Laura', 'Andrew', 'Julia'],
		pets => ['Cat', 'Bird'],
	} );  
	result( UNIVERSAL::isa( $mvh3, "Data::MultiValuedHash" ), 
		"mvh3 = new( 0, {...} ) ret MVH obj" );

	$did = $mvh3->ignores_case();
	result( $did == 0, "on init mvh3->ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh3->fetch_all() ) );
	$should = "{ 'Name' => [ 'John', ], 'Siblings' => [ 'Laura', 'Andrew', ".
		"'Julia', ], 'age' => [ '17', ], 'color' => [ 'green', ], 'pets' => ".
		"[ 'Cat', 'Bird', ], }, ";
	result( $did eq $should, "on init mvh3->fetch_all() returns '$did'" );

	# make new with initial values, case-insensitive keys

	my $mvh4 = Data::MultiValuedHash->new( 1, {
		Name => 'John',
		age => 17,
		color => 'green',
		Siblings => ['Laura', 'Andrew', 'Julia'],
		pets => ['Cat', 'Bird'],
	} );  
	result( UNIVERSAL::isa( $mvh4, "Data::MultiValuedHash" ), 
		"mvh4 = new( 1, {...} ) ret MVH obj" );

	$did = $mvh4->ignores_case();
	result( $did == 1, "on init mvh4->ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh4->fetch_all() ) );
	$should = "{ 'age' => [ '17', ], 'color' => [ 'green', ], ".
		"'name' => [ 'John', ], 'pets' => [ 'Cat', 'Bird', ], ".
		"'siblings' => [ 'Laura', 'Andrew', 'Julia', ], }, ";
	result( $did eq $should, "on init mvh4->fetch_all() returns '$did'" );

	# make new with initial values from mvh3, case-sensitive keys

	my $mvh5 = Data::MultiValuedHash->new( 0, $mvh3 );  
	result( UNIVERSAL::isa( $mvh5, "Data::MultiValuedHash" ), 
		"mvh5 = new( 0, mvh3 ) ret MVH obj" );

	$did = $mvh5->ignores_case();
	result( $did == 0, "on init mvh5->ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh5->fetch_all() ) );
	$should = "{ 'Name' => [ 'John', ], 'Siblings' => [ 'Laura', 'Andrew', ".
		"'Julia', ], 'age' => [ '17', ], 'color' => [ 'green', ], 'pets' => ".
		"[ 'Cat', 'Bird', ], }, ";
	result( $did eq $should, "on init mvh5->fetch_all() returns '$did'" );

	# make new with initial values from mvh3, case-insensitive keys

	my $mvh6 = Data::MultiValuedHash->new( 1, $mvh3 );  
	result( UNIVERSAL::isa( $mvh4, "Data::MultiValuedHash" ), 
		"mvh6 = new( 1, mvh3 ) ret MVH obj" );

	$did = $mvh6->ignores_case();
	result( $did == 1, "on init mvh6->ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh6->fetch_all() ) );
	$should = "{ 'age' => [ '17', ], 'color' => [ 'green', ], ".
		"'name' => [ 'John', ], 'pets' => [ 'Cat', 'Bird', ], ".
		"'siblings' => [ 'Laura', 'Andrew', 'Julia', ], }, ";
	result( $did eq $should, "on init mvh6->fetch_all() returns '$did'" );
	
	# make new as a clone of mvh1 - no values, case-sensitive
	
	my $mvh7 = $mvh1->clone();
	result( UNIVERSAL::isa( $mvh7, "Data::MultiValuedHash" ), 
		"mvh7 = mvh1->clone() ret MVH obj" );

	$did = $mvh7->ignores_case();
	result( $did == 0, "on clone mvh7->ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh7->fetch_all() ) );
	$should = "{ }, ";
	result( $did eq $should, "on clone mvh7->fetch_all() returns '$did'" );
	
	# make new as a clone of mvh4 - some values, case-insensitive
	
	my $mvh8 = $mvh4->clone();
	result( UNIVERSAL::isa( $mvh8, "Data::MultiValuedHash" ), 
		"mvh8 = mvh4->clone() ret MVH obj" );

	$did = $mvh8->ignores_case();
	result( $did == 1, "on clone mvh8->ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh8->fetch_all() ) );
	$should = "{ 'age' => [ '17', ], 'color' => [ 'green', ], ".
		"'name' => [ 'John', ], 'pets' => [ 'Cat', 'Bird', ], ".
		"'siblings' => [ 'Laura', 'Andrew', 'Julia', ], }, ";
	result( $did eq $should, "on clone mvh8->fetch_all() returns '$did'" );
}

######################################################################
# test ignores_case()

{
	message( "testing ignores_case()" );

	my ($mvh, $did, $should);
	
	# convert from false to false

	$mvh = Data::MultiValuedHash->new( 0, {
		Name => 'John',
		age => 17,
		color => 'green',
		Siblings => ['Laura', 'Andrew', 'Julia'],
		pets => ['Cat', 'Bird'],
	} ); 
	$mvh->ignores_case( 0 );
	
	$did = $mvh->ignores_case();
	result( $did == 0, "ign-case from 0 to 0; ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all() ) );
	$should = "{ 'Name' => [ 'John', ], 'Siblings' => [ 'Laura', 'Andrew', ".
		"'Julia', ], 'age' => [ '17', ], 'color' => [ 'green', ], 'pets' => ".
		"[ 'Cat', 'Bird', ], }, ";
	result( $did eq $should, "ign-case from 0 to 0; fetch_all() returns '$did'" );
	
	# convert from false to true

	$mvh = Data::MultiValuedHash->new( 0, {
		Name => 'John',
		age => 17,
		color => 'green',
		Siblings => ['Laura', 'Andrew', 'Julia'],
		pets => ['Cat', 'Bird'],
	} ); 
	$mvh->ignores_case( 1 );
	
	$did = $mvh->ignores_case();
	result( $did == 1, "ign-case from 0 to 1; ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all() ) );
	$should = "{ 'age' => [ '17', ], 'color' => [ 'green', ], ".
		"'name' => [ 'John', ], 'pets' => [ 'Cat', 'Bird', ], ".
		"'siblings' => [ 'Laura', 'Andrew', 'Julia', ], }, ";
	result( $did eq $should, "ign-case from 0 to 1; fetch_all() returns '$did'" );
	
	# convert from true to false

	$mvh = Data::MultiValuedHash->new( 1, {
		Name => 'John',
		age => 17,
		color => 'green',
		Siblings => ['Laura', 'Andrew', 'Julia'],
		pets => ['Cat', 'Bird'],
	} ); 
	$mvh->ignores_case( 0 );
	
	$did = $mvh->ignores_case();
	result( $did == 0, "ign-case from 1 to 0; ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all() ) );
	$should = "{ 'age' => [ '17', ], 'color' => [ 'green', ], ".
		"'name' => [ 'John', ], 'pets' => [ 'Cat', 'Bird', ], ".
		"'siblings' => [ 'Laura', 'Andrew', 'Julia', ], }, ";
	result( $did eq $should, "ign-case from 1 to 0; fetch_all() returns '$did'" );
	
	# convert from true to true

	$mvh = Data::MultiValuedHash->new( 1, {
		Name => 'John',
		age => 17,
		color => 'green',
		Siblings => ['Laura', 'Andrew', 'Julia'],
		pets => ['Cat', 'Bird'],
	} ); 
	$mvh->ignores_case( 1 );
	
	$did = $mvh->ignores_case();
	result( $did == 1, "ign-case from 1 to 1; ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all() ) );
	$should = "{ 'age' => [ '17', ], 'color' => [ 'green', ], ".
		"'name' => [ 'John', ], 'pets' => [ 'Cat', 'Bird', ], ".
		"'siblings' => [ 'Laura', 'Andrew', 'Julia', ], }, ";
	result( $did eq $should, "ign-case from 1 to 1; fetch_all() returns '$did'" );
}

######################################################################
# test read-only methods on case-sensitive MVH

{
	message( "testing read-only methods on case-sensitive MVH" );

	my ($mvh, $did, $should);
	
	# first initialize data we will be reading from
	
	$mvh = Data::MultiValuedHash->new( 0, {
		Name => 'John',
		age => 17,
		color => 'green',
		Siblings => ['Laura', 'Andrew', 'Julia'],
		pets => ['Cat', 'Bird'],
	} ); 

	# now we do keys(), values(), and the like

	$did = serialize( [ sort $mvh->keys() ] );
	$should = "[ 'Name', 'Siblings', 'age', 'color', 'pets', ], ";
	result( $did eq $should, "sort keys() returns '$did'" );

	$did = serialize( scalar( $mvh->keys_count() ) );
	$should = "'5', ";
	result( $did eq $should, "keys_count() returns '$did'" );

	$did = serialize( [ sort $mvh->values() ] );
	$should = "[ '17', 'Andrew', 'Bird', 'Cat', 'John', 'Julia', 'Laura', 'green', ], ";
	result( $did eq $should, "sort values() returns '$did'" );

	$did = serialize( scalar( $mvh->values_count() ) );
	$should = "'8', ";
	result( $did eq $should, "values_count() returns '$did'" );

	# now we do exists()

	$did = serialize( scalar( $mvh->exists() ) );
	$should = "'', ";
	result( $did eq $should, "exists() returns '$did'" );

	$did = serialize( scalar( $mvh->exists( 'name' ) ) );
	$should = "'', ";
	result( $did eq $should, "exists( 'name' ) returns '$did'" );

	$did = serialize( scalar( $mvh->exists( 'Name' ) ) );
	$should = "'1', ";
	result( $did eq $should, "exists( 'Name' ) returns '$did'" );

	$did = serialize( scalar( $mvh->exists( 'color' ) ) );
	$should = "'1', ";
	result( $did eq $should, "exists( 'color' ) returns '$did'" );

	$did = serialize( scalar( $mvh->exists( 'Color' ) ) );
	$should = "'', ";
	result( $did eq $should, "exists( 'Color' ) returns '$did'" );

	# now we do count()

	$did = serialize( scalar( $mvh->count() ) );
	$should = "undef, ";
	result( $did eq $should, "count() returns '$did'" );

	$did = serialize( scalar( $mvh->count( 'name' ) ) );
	$should = "undef, ";
	result( $did eq $should, "count( 'name' ) returns '$did'" );

	$did = serialize( scalar( $mvh->count( 'age' ) ) );
	$should = "'1', ";
	result( $did eq $should, "count( 'age' ) returns '$did'" );

	$did = serialize( scalar( $mvh->count( 'pets' ) ) );
	$should = "'2', ";
	result( $did eq $should, "count( 'pets' ) returns '$did'" );

	# now we do fetch_value()

	$did = serialize( scalar( $mvh->fetch_value() ) );
	$should = "undef, ";
	result( $did eq $should, "fetch_value() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_value( 'name' ) ) );
	$should = "undef, ";
	result( $did eq $should, "fetch_value( 'name' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_value( 'age' ) ) );
	$should = "'17', ";
	result( $did eq $should, "fetch_value( 'age' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_value( 'Siblings' ) ) );
	$should = "'Laura', ";
	result( $did eq $should, "fetch_value( 'Siblings' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_value( 'age', 0 ) ) );
	$should = "'17', ";
	result( $did eq $should, "fetch_value( 'age', 0 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_value( 'Siblings', 0 ) ) );
	$should = "'Laura', ";
	result( $did eq $should, "fetch_value( 'Siblings', 0 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_value( 'age', 1 ) ) );
	$should = "undef, ";
	result( $did eq $should, "fetch_value( 'age', 1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_value( 'Siblings', 1 ) ) );
	$should = "'Andrew', ";
	result( $did eq $should, "fetch_value( 'Siblings', 1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_value( 'age', -1 ) ) );
	$should = "'17', ";
	result( $did eq $should, "fetch_value( 'age', -1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_value( 'Siblings', -1 ) ) );
	$should = "'Julia', ";
	result( $did eq $should, "fetch_value( 'Siblings', -1 ) returns '$did'" );

	# now we do fetch()

	$did = serialize( scalar( $mvh->fetch() ) );
	$should = "undef, ";
	result( $did eq $should, "fetch() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'name' ) ) );
	$should = "undef, ";
	result( $did eq $should, "fetch( 'name' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'age' ) ) );
	$should = "[ '17', ], ";
	result( $did eq $should, "fetch( 'age' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'Siblings' ) ) );
	$should = "[ 'Laura', 'Andrew', 'Julia', ], ";
	result( $did eq $should, "fetch( 'Siblings' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'age', 0 ) ) );
	$should = "[ '17', ], ";
	result( $did eq $should, "fetch( 'age', 0 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'Siblings', 0 ) ) );
	$should = "[ 'Laura', ], ";
	result( $did eq $should, "fetch( 'Siblings', 0 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'age', 1 ) ) );
	$should = "[ undef, ], ";
	result( $did eq $should, "fetch( 'age', 1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'Siblings', 1 ) ) );
	$should = "[ 'Andrew', ], ";
	result( $did eq $should, "fetch( 'Siblings', 1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'age', -1 ) ) );
	$should = "[ '17', ], ";
	result( $did eq $should, "fetch( 'age', -1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'Siblings', -1 ) ) );
	$should = "[ 'Julia', ], ";
	result( $did eq $should, "fetch( 'Siblings', -1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'age', [0..1] ) ) );
	$should = "[ '17', undef, ], ";
	result( $did eq $should, "fetch( 'age', [0..1] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'Siblings', [0..1] ) ) );
	$should = "[ 'Laura', 'Andrew', ], ";
	result( $did eq $should, "fetch( 'Siblings', [0..1] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'Siblings', [1..4] ) ) );
	$should = "[ 'Andrew', 'Julia', undef, undef, ], ";
	result( $did eq $should, "fetch( 'Siblings', [1..4] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'Siblings', [-1,1] ) ) );
	$should = "[ 'Julia', 'Andrew', ], ";
	result( $did eq $should, "fetch( 'Siblings', [-1,1] ) returns '$did'" );
	
	# now we do fetch_hash()

	$did = serialize( scalar( $mvh->fetch_hash() ) );
	$should = "{ 'Name' => 'John', 'Siblings' => 'Laura', 'age' => '17', 'color' => 'green', 'pets' => 'Cat', }, ";
	result( $did eq $should, "fetch_hash() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_hash( 0 ) ) );
	$should = "{ 'Name' => 'John', 'Siblings' => 'Laura', 'age' => '17', 'color' => 'green', 'pets' => 'Cat', }, ";
	result( $did eq $should, "fetch_hash( 0 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_hash( 1 ) ) );
	$should = "{ 'Name' => undef, 'Siblings' => 'Andrew', 'age' => undef, 'color' => undef, 'pets' => 'Bird', }, ";
	result( $did eq $should, "fetch_hash( 1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_hash( 2 ) ) );
	$should = "{ 'Name' => undef, 'Siblings' => 'Julia', 'age' => undef, 'color' => undef, 'pets' => undef, }, ";
	result( $did eq $should, "fetch_hash( 2 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_hash( 3 ) ) );
	$should = "{ 'Name' => undef, 'Siblings' => undef, 'age' => undef, 'color' => undef, 'pets' => undef, }, ";
	result( $did eq $should, "fetch_hash( 3 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_hash( -1 ) ) );
	$should = "{ 'Name' => 'John', 'Siblings' => 'Julia', 'age' => '17', 'color' => 'green', 'pets' => 'Bird', }, ";
	result( $did eq $should, "fetch_hash( -1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_hash( undef, ['age','pets'] ) ) );
	$should = "{ 'age' => '17', 'pets' => 'Cat', }, ";
	result( $did eq $should, "fetch_hash( undef, ['age','pets'] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_hash( 1, ['age','Siblings'] ) ) );
	$should = "{ 'Siblings' => 'Andrew', 'age' => undef, }, ";
	result( $did eq $should, "fetch_hash( 1, ['age','Siblings'] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_hash( undef, ['age','pets'], 1 ) ) );
	$should = "{ 'Name' => 'John', 'Siblings' => 'Laura', 'color' => 'green', }, ";
	result( $did eq $should, "fetch_hash( undef, ['age','pets'], 1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_hash( 1, ['age','Siblings'], 1 ) ) );
	$should = "{ 'Name' => undef, 'color' => undef, 'pets' => 'Bird', }, ";
	result( $did eq $should, "fetch_hash( 1, ['age','Siblings'], 1 ) returns '$did'" );

	# now we do fetch_first()

	$did = serialize( scalar( $mvh->fetch_first() ) );
	$should = "{ 'Name' => 'John', 'Siblings' => 'Laura', 'age' => '17', 'color' => 'green', 'pets' => 'Cat', }, ";
	result( $did eq $should, "fetch_first() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_first( ['age','Siblings'] ) ) );
	$should = "{ 'Siblings' => 'Laura', 'age' => '17', }, ";
	result( $did eq $should, "fetch_first( ['age','Siblings'] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_first( ['age','Siblings'], 1 ) ) );
	$should = "{ 'Name' => 'John', 'color' => 'green', 'pets' => 'Cat', }, ";
	result( $did eq $should, "fetch_first( ['age','Siblings'], 1 ) returns '$did'" );

	# now we do fetch_last()

	$did = serialize( scalar( $mvh->fetch_last() ) );
	$should = "{ 'Name' => 'John', 'Siblings' => 'Julia', 'age' => '17', 'color' => 'green', 'pets' => 'Bird', }, ";
	result( $did eq $should, "fetch_last() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_last( ['age','Siblings'] ) ) );
	$should = "{ 'Siblings' => 'Julia', 'age' => '17', }, ";
	result( $did eq $should, "fetch_last( ['age','Siblings'] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_last( ['age','Siblings'], 1 ) ) );
	$should = "{ 'Name' => 'John', 'color' => 'green', 'pets' => 'Bird', }, ";
	result( $did eq $should, "fetch_last( ['age','Siblings'], 1 ) returns '$did'" );
	
	# now we do fetch_all()
	
	$did = serialize( scalar( $mvh->fetch_all() ) );
	$should = "{ 'Name' => [ 'John', ], 'Siblings' => [ 'Laura', 'Andrew', 'Julia', ], 'age' => [ '17', ], 'color' => [ 'green', ], 'pets' => [ 'Cat', 'Bird', ], }, ";
	result( $did eq $should, "fetch_all() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( undef, undef, 0 ) ) );
	$should = "{ 'Name' => [ 'John', ], 'Siblings' => [ 'Laura', ], 'age' => [ '17', ], 'color' => [ 'green', ], 'pets' => [ 'Cat', ], }, ";
	result( $did eq $should, "fetch_all( undef, undef, 0 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( undef, undef, 1 ) ) );
	$should = "{ 'Name' => [ undef, ], 'Siblings' => [ 'Andrew', ], 'age' => [ undef, ], 'color' => [ undef, ], 'pets' => [ 'Bird', ], }, ";
	result( $did eq $should, "fetch_all( undef, undef, 1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( undef, undef, 2 ) ) );
	$should = "{ 'Name' => [ undef, ], 'Siblings' => [ 'Julia', ], 'age' => [ undef, ], 'color' => [ undef, ], 'pets' => [ undef, ], }, ";
	result( $did eq $should, "fetch_all( undef, undef, 2 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( undef, undef, 3 ) ) );
	$should = "{ 'Name' => [ undef, ], 'Siblings' => [ undef, ], 'age' => [ undef, ], 'color' => [ undef, ], 'pets' => [ undef, ], }, ";
	result( $did eq $should, "fetch_all( undef, undef, 3 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( undef, undef, -1 ) ) );
	$should = "{ 'Name' => [ 'John', ], 'Siblings' => [ 'Julia', ], 'age' => [ '17', ], 'color' => [ 'green', ], 'pets' => [ 'Bird', ], }, ";
	result( $did eq $should, "fetch_all( undef, undef, -1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( ['age','pets'], undef, 0 ) ) );
	$should = "{ 'age' => [ '17', ], 'pets' => [ 'Cat', ], }, ";
	result( $did eq $should, "fetch_all( ['age','pets'], undef, 0 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( ['age','Siblings'], undef, 1 ) ) );
	$should = "{ 'Siblings' => [ 'Andrew', ], 'age' => [ undef, ], }, ";
	result( $did eq $should, "fetch_all( ['age','Siblings'], undef, 1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( ['age','pets'], 1, 0 ) ) );
	$should = "{ 'Name' => [ 'John', ], 'Siblings' => [ 'Laura', ], 'color' => [ 'green', ], }, ";
	result( $did eq $should, "fetch_all( ['age','pets'], 1, 0 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( ['age','Siblings'], 1, 1 ) ) );
	$should = "{ 'Name' => [ undef, ], 'color' => [ undef, ], 'pets' => [ 'Bird', ], }, ";
	result( $did eq $should, "fetch_all( ['age','Siblings'], 1, 1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( 'name' ) ) );
	$should = "{ }, ";
	result( $did eq $should, "fetch_all( 'name' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( 'age' ) ) );
	$should = "{ 'age' => [ '17', ], }, ";
	result( $did eq $should, "fetch_all( 'age' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( 'Siblings' ) ) );
	$should = "{ 'Siblings' => [ 'Laura', 'Andrew', 'Julia', ], }, ";
	result( $did eq $should, "fetch_all( 'Siblings' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( 'age', undef, 0 ) ) );
	$should = "{ 'age' => [ '17', ], }, ";
	result( $did eq $should, "fetch_all( 'age', undef, 0 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( 'Siblings', undef, 0 ) ) );
	$should = "{ 'Siblings' => [ 'Laura', ], }, ";
	result( $did eq $should, "fetch_all( 'Siblings', undef, 0 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( 'age', undef, 1 ) ) );
	$should = "{ 'age' => [ undef, ], }, ";
	result( $did eq $should, "fetch_all( 'age', undef, 1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( 'Siblings', undef, 1 ) ) );
	$should = "{ 'Siblings' => [ 'Andrew', ], }, ";
	result( $did eq $should, "fetch_all( 'Siblings', undef, 1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( 'age', undef, -1 ) ) );
	$should = "{ 'age' => [ '17', ], }, ";
	result( $did eq $should, "fetch_all( 'age', undef, -1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( 'Siblings', undef, -1 ) ) );
	$should = "{ 'Siblings' => [ 'Julia', ], }, ";
	result( $did eq $should, "fetch_all( 'Siblings', undef, -1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( 'age', undef, [0..1] ) ) );
	$should = "{ 'age' => [ '17', undef, ], }, ";
	result( $did eq $should, "fetch_all( 'age', undef, [0..1] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( 'Siblings', undef, [0..1] ) ) );
	$should = "{ 'Siblings' => [ 'Laura', 'Andrew', ], }, ";
	result( $did eq $should, "fetch_all( 'Siblings', undef, [0..1] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( 'Siblings', undef, [1..4] ) ) );
	$should = "{ 'Siblings' => [ 'Andrew', 'Julia', undef, undef, ], }, ";
	result( $did eq $should, "fetch_all( 'Siblings', undef, [1..4] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( 'Siblings', undef, [-1,1] ) ) );
	$should = "{ 'Siblings' => [ 'Julia', 'Andrew', ], }, ";
	result( $did eq $should, "fetch_all( 'Siblings', undef, [-1,1] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( ['Siblings','pets'], undef, [-1,1] ) ) );
	$should = "{ 'Siblings' => [ 'Julia', 'Andrew', ], 'pets' => [ 'Bird', 'Bird', ], }, ";
	result( $did eq $should, "fetch_all( ['Siblings','pets'], undef, [-1,1] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( ['Name','Siblings','pets'], 1, [-1,1] ) ) );
	$should = "{ 'age' => [ '17', undef, ], 'color' => [ 'green', undef, ], }, ";
	result( $did eq $should, "fetch_all( ['Name','Siblings','pets'], 1, [-1,1] ) returns '$did'" );
	
	

}

######################################################################
# test read-only methods on case-insensitive MVH

{
	message( "testing read-only methods on case-insensitive MVH" );

	my ($mvh, $did, $should);
	
	# first initialize data we will be reading from
	
	$mvh = Data::MultiValuedHash->new( 1, {
		Name => 'John',
		age => 17,
		color => 'green',
		Siblings => ['Laura', 'Andrew', 'Julia'],
		pets => ['Cat', 'Bird'],
	} ); 

	# now we do keys(), values(), and the like

	$did = serialize( [ sort $mvh->keys() ] );
	$should = "[ 'age', 'color', 'name', 'pets', 'siblings', ], ";
	result( $did eq $should, "sort keys() returns '$did'" );

	$did = serialize( scalar( $mvh->keys_count() ) );
	$should = "'5', ";
	result( $did eq $should, "keys_count() returns '$did'" );

	$did = serialize( [ sort $mvh->values() ] );
	$should = "[ '17', 'Andrew', 'Bird', 'Cat', 'John', 'Julia', 'Laura', 'green', ], ";
	result( $did eq $should, "sort values() returns '$did'" );

	$did = serialize( scalar( $mvh->values_count() ) );
	$should = "'8', ";
	result( $did eq $should, "values_count() returns '$did'" );

	# now we do exists()

	$did = serialize( scalar( $mvh->exists( 'name' ) ) );
	$should = "'1', ";
	result( $did eq $should, "exists( 'name' ) returns '$did'" );

	$did = serialize( scalar( $mvh->exists( 'Name' ) ) );
	$should = "'1', ";
	result( $did eq $should, "exists( 'Name' ) returns '$did'" );

	$did = serialize( scalar( $mvh->exists( 'color' ) ) );
	$should = "'1', ";
	result( $did eq $should, "exists( 'color' ) returns '$did'" );

	$did = serialize( scalar( $mvh->exists( 'Color' ) ) );
	$should = "'1', ";
	result( $did eq $should, "exists( 'Color' ) returns '$did'" );

	# now we do fetch_value()

	$did = serialize( scalar( $mvh->fetch_value( 'name' ) ) );
	$should = "'John', ";
	result( $did eq $should, "fetch_value( 'name' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_value( 'age' ) ) );
	$should = "'17', ";
	result( $did eq $should, "fetch_value( 'age' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_value( 'Siblings' ) ) );
	$should = "'Laura', ";
	result( $did eq $should, "fetch_value( 'Siblings' ) returns '$did'" );

	# now we do fetch()

	$did = serialize( scalar( $mvh->fetch( 'name' ) ) );
	$should = "[ 'John', ], ";
	result( $did eq $should, "fetch( 'name' ) returns '$did'" );

	# now we do fetch_hash()

	$did = serialize( scalar( $mvh->fetch_hash() ) );
	$should = "{ 'age' => '17', 'color' => 'green', 'name' => 'John', 'pets' => 'Cat', 'siblings' => 'Laura', }, ";
	result( $did eq $should, "fetch_hash() returns '$did'" );

	# now we do fetch_first()

	$did = serialize( scalar( $mvh->fetch_first( ['age','Siblings'] ) ) );
	$should = "{ 'age' => '17', 'siblings' => 'Laura', }, ";
	result( $did eq $should, "fetch_first( ['age','Siblings'] ) returns '$did'" );

	# now we do fetch_last()

	$did = serialize( scalar( $mvh->fetch_last( ['age','Siblings'], 1 ) ) );
	$should = "{ 'color' => 'green', 'name' => 'John', 'pets' => 'Bird', }, ";
	result( $did eq $should, "fetch_last( ['age','Siblings'], 1 ) returns '$did'" );
	
	# now we do fetch_all()
	
	$did = serialize( scalar( $mvh->fetch_all() ) );
	$should = "{ 'age' => [ '17', ], 'color' => [ 'green', ], 'name' => [ 'John', ], 'pets' => [ 'Cat', 'Bird', ], 'siblings' => [ 'Laura', 'Andrew', 'Julia', ], }, ";
	result( $did eq $should, "fetch_all() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( ['Siblings','pets'], undef, [-1,1] ) ) );
	$should = "{ 'pets' => [ 'Bird', 'Bird', ], 'siblings' => [ 'Julia', 'Andrew', ], }, ";
	result( $did eq $should, "fetch_all( ['Siblings','pets'], undef, [-1,1] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( ['Name','Siblings','pets'], 1, [-1,1] ) ) );
	$should = "{ 'age' => [ '17', undef, ], 'color' => [ 'green', undef, ], }, ";
	result( $did eq $should, "fetch_all( ['Name','Siblings','pets'], 1, [-1,1] ) returns '$did'" );
}
	
######################################################################
# test fetch_mvh()

{
	message( "testing fetch_mvh()" );

	my ($mvh1, $mvh2, $mvh3, $did, $should);
	
	$mvh1 = Data::MultiValuedHash->new( 1, {
		Name => 'John',
		age => 17,
		color => 'green',
		Siblings => ['Laura', 'Andrew', 'Julia'],
		pets => ['Cat', 'Bird'],
	} ); 

	# first, emulate clone()

	$mvh2 = $mvh1->fetch_mvh();
	result( UNIVERSAL::isa( $mvh2, "Data::MultiValuedHash" ), 
		"mvh2 = mvh1->fetch_mvh() ret MVH obj" );

	$did = $mvh2->ignores_case();
	result( $did == 1, "on fetch_mvh mvh2->ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh2->fetch_all() ) );
	$should = "{ 'age' => [ '17', ], 'color' => [ 'green', ], ".
		"'name' => [ 'John', ], 'pets' => [ 'Cat', 'Bird', ], ".
		"'siblings' => [ 'Laura', 'Andrew', 'Julia', ], }, ";
	result( $did eq $should, "on fetch_mvh mvh2->fetch_all() returns '$did'" );

	# then try a subset

	$mvh3 = $mvh1->fetch_mvh( ['name','siblings'] );
	result( UNIVERSAL::isa( $mvh3, "Data::MultiValuedHash" ), 
		"mvh3 = mvh1->fetch_mvh( ['name','siblings'] ) ret MVH obj" );

	$did = $mvh3->ignores_case();
	result( $did == 1, "on fetch_mvh mvh3->ignores_case() returns '$did'" );

	$did = serialize( scalar( $mvh3->fetch_all() ) );
	$should = "{ 'name' => [ 'John', ], 'siblings' => [ 'Laura', 'Andrew', 'Julia', ], }, ";
	result( $did eq $should, "on fetch_mvh mvh3->fetch_all() returns '$did'" );
}
	
######################################################################
# test altering methods like store()

{
	message( "testing altering methods like store()" );

	my ($mvh, $did, $should);
	
	# first initialize data we will be reading from
	
	$mvh = Data::MultiValuedHash->new( 0, {
		Name => 'John',
		age => 17,
		color => 'green',
		Siblings => ['Laura', 'Andrew', 'Julia'],
		pets => ['Cat', 'Bird'],
	} ); 

	# now we do store_value()

	$did = $mvh->store_value( 'pets', 'turtle' );
	result( $did == 2, "store_value( 'pets', 'turtle' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_value( 'pets' ) ) );
	$should = "'turtle', ";
	result( $did eq $should, "fetch_value( 'pets' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'pets' ) ) );
	$should = "[ 'turtle', 'Bird', ], ";
	result( $did eq $should, "fetch( 'pets' ) returns '$did'" );

	$did = $mvh->store_value( 'pets', 'rabbit', 1 );
	result( $did == 2, "store_value( 'pets', 'rabbit', 1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_value( 'pets', 1 ) ) );
	$should = "'rabbit', ";
	result( $did eq $should, "fetch_value( 'pets', 1 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'pets' ) ) );
	$should = "[ 'turtle', 'rabbit', ], ";
	result( $did eq $should, "fetch( 'pets' ) returns '$did'" );

	# now we do store()

	$did = $mvh->store( 'age', 18 );
	result( $did == 1, "store( 'age', 18 ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'age' ) ) );
	$should = "[ '18', ], ";
	result( $did eq $should, "fetch( 'age' ) returns '$did'" );

	$did = $mvh->store( 'Name', [] );
	result( $did == 0, "store( 'Name', [] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'Name' ) ) );
	$should = "[ ], ";
	result( $did eq $should, "fetch( 'Name' ) returns '$did'" );

	$did = $mvh->store( 'Name', [ 'John', 'Reese' ] );
	result( $did == 2, "store( 'Name', [ 'John', 'Reese', ] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'Name' ) ) );
	$should = "[ 'John', 'Reese', ], ";
	result( $did eq $should, "fetch( 'Name' ) returns '$did'" );

	$did = $mvh->store( 'Name', 'John', 'Glenn' );
	result( $did == 2, "store( 'Name', 'John', 'Glenn' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'Name' ) ) );
	$should = "[ 'John', 'Glenn', ], ";
	result( $did eq $should, "fetch( 'Name' ) returns '$did'" );
	
	# now we do store_all()

	$did = $mvh->store_all( {
		songs => ['here','we','go'],
		pets => 'Lobster',
	} );
	result( $did == 2, "store_all( {songs => ['here','we','go'],".
		"pets => 'Lobster',} ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( ['songs','pets'] ) ) );
	$should = "{ 'pets' => [ 'Lobster', ], 'songs' => [ 'here', 'we', 'go', ], }, ";
	result( $did eq $should, "fetch_all( ['songs','pets'] ) returns '$did'" );

	$did = $mvh->store_all(
		songs => ['this','that','and the other'],
		pets => 'Fish',
	);
	result( $did == 2, "store_all( songs => ['this','that','and the other'],".
		"pets => 'Fish', ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( ['songs','pets'] ) ) );
	$should = "{ 'pets' => [ 'Fish', ], 'songs' => [ 'this', 'that', 'and the other', ], }, ";
	result( $did eq $should, "fetch_all( ['songs','pets'] ) returns '$did'" );

	$did = $mvh->store_all();
	result( $did == 0, "store_all() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all( [] ) ) );
	$should = "{ }, ";
	result( $did eq $should, "fetch_all( [] ) returns '$did'" );

	# now we do push()

	$did = $mvh->push();
	result( $did == 0, "push() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch() ) );
	$should = "[ ], ";
	result( $did eq $should, "fetch() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( undef ) ) );
	$should = "[ ], ";
	result( $did eq $should, "fetch( undef ) returns '$did'" );

	$did = $mvh->push( 'Siblings' );
	result( $did == 3, "push( 'Siblings' ) returns '$did'" );

	$did = $mvh->push( 'Siblings', [] );
	result( $did == 3, "push( 'Siblings', [] ) returns '$did'" );

	$did = $mvh->push( 'Siblings', 'Tandy' );
	result( $did == 4, "push( 'Siblings', 'Tandy' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'Siblings' ) ) );
	$should = "[ 'Laura', 'Andrew', 'Julia', 'Tandy', ], ";
	result( $did eq $should, "fetch( 'Siblings' ) returns '$did'" );

	$did = $mvh->push( 'Siblings', ['Adam','Jessie'] );
	result( $did == 6, "push( 'Siblings', ['Adam','Jessie'] ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'Siblings' ) ) );
	$should = "[ 'Laura', 'Andrew', 'Julia', 'Tandy', 'Adam', 'Jessie', ], ";
	result( $did eq $should, "fetch( 'Siblings' ) returns '$did'" );
	
	# now we do unshift()

	$did = $mvh->unshift( 'pets', 'Dog', 'Hamster' );
	result( $did == 3, "unshift( 'pets', 'Dog', 'Hamster' ) returns '$did'" );

	$did = serialize( scalar( $mvh->fetch( 'pets' ) ) );
	$should = "[ 'Dog', 'Hamster', 'Fish', ], ";
	result( $did eq $should, "fetch( 'pets' ) returns '$did'" );
	
	# now we do pop()

	$did = serialize( scalar( $mvh->pop( 'pets' ) ) );
	$should = "'Fish', ";
	result( $did eq $should, "pop( 'pets' ) returns '$did'" );
	
	$did = serialize( scalar( $mvh->fetch( 'pets' ) ) );
	$should = "[ 'Dog', 'Hamster', ], ";
	result( $did eq $should, "fetch( 'pets' ) returns '$did'" );

	$did = serialize( scalar( $mvh->pop( 'Pets' ) ) );
	$should = "undef, ";
	result( $did eq $should, "pop( 'Pets' ) returns '$did'" );
	
	$did = serialize( scalar( $mvh->fetch( 'Pets' ) ) );
	$should = "undef, ";
	result( $did eq $should, "fetch( 'Pets' ) returns '$did'" );
	
	# now we do shift()

	$did = serialize( scalar( $mvh->shift( 'color' ) ) );
	$should = "'green', ";
	result( $did eq $should, "shift( 'color' ) returns '$did'" );
	
	$did = serialize( scalar( $mvh->fetch( 'color' ) ) );
	$should = "[ ], ";
	result( $did eq $should, "fetch( 'color' ) returns '$did'" );

	$did = serialize( scalar( $mvh->shift( 'color' ) ) );
	$should = "undef, ";
	result( $did eq $should, "shift( 'color' ) returns '$did'" );
	
	$did = serialize( scalar( $mvh->fetch( 'color' ) ) );
	$should = "[ ], ";
	result( $did eq $should, "fetch( 'color' ) returns '$did'" );
	
	# now we do splice()

	$did = serialize( scalar( $mvh->splice( 'Siblings', 0, 1 ) ) );
	$should = "[ 'Laura', ], ";
	result( $did eq $should, "splice( 'Siblings', 0, 1 ) returns '$did'" );
	
	$did = serialize( scalar( $mvh->fetch( 'Siblings' ) ) );
	$should = "[ 'Andrew', 'Julia', 'Tandy', 'Adam', 'Jessie', ], ";
	result( $did eq $should, "fetch( 'Siblings' ) returns '$did'" );

	$did = serialize( scalar( $mvh->splice( 'Siblings', 3, 1, 'Evette' ) ) );
	$should = "[ 'Adam', ], ";
	result( $did eq $should, "splice( 'Siblings', 3, 1, 'Evette' ) returns '$did'" );
	
	$did = serialize( scalar( $mvh->fetch( 'Siblings' ) ) );
	$should = "[ 'Andrew', 'Julia', 'Tandy', 'Evette', 'Jessie', ], ";
	result( $did eq $should, "fetch( 'Siblings' ) returns '$did'" );

	$did = serialize( scalar( $mvh->splice( 'Siblings', 3, 0, ['James'] ) ) );
	$should = "[ ], ";
	result( $did eq $should, "splice( 'Siblings', 3, 0, ['James'] ) returns '$did'" );
	
	$did = serialize( scalar( $mvh->fetch( 'Siblings' ) ) );
	$should = "[ 'Andrew', 'Julia', 'Tandy', 'James', 'Evette', 'Jessie', ], ";
	result( $did eq $should, "fetch( 'Siblings' ) returns '$did'" );

	$did = serialize( scalar( $mvh->splice( 'Siblings', -1 ) ) );
	$should = "[ 'Jessie', ], ";
	result( $did eq $should, "splice( 'Siblings', -1 ) returns '$did'" );
	
	$did = serialize( scalar( $mvh->fetch( 'Siblings' ) ) );
	$should = "[ 'Andrew', 'Julia', 'Tandy', 'James', 'Evette', ], ";
	result( $did eq $should, "fetch( 'Siblings' ) returns '$did'" );

	$did = serialize( scalar( $mvh->splice( 'Siblings', 3 ) ) );
	$should = "[ 'James', 'Evette', ], ";
	result( $did eq $should, "splice( 'Siblings', 3 ) returns '$did'" );
	
	$did = serialize( scalar( $mvh->fetch( 'Siblings' ) ) );
	$should = "[ 'Andrew', 'Julia', 'Tandy', ], ";
	result( $did eq $should, "fetch( 'Siblings' ) returns '$did'" );

	$did = serialize( scalar( $mvh->splice( 'Siblings' ) ) );
	$should = "[ 'Andrew', 'Julia', 'Tandy', ], ";
	result( $did eq $should, "splice( 'Siblings' ) returns '$did'" );
	
	$did = serialize( scalar( $mvh->fetch( 'Siblings' ) ) );
	$should = "[ ], ";
	result( $did eq $should, "fetch( 'Siblings' ) returns '$did'" );

	# now we do delete()

	$did = serialize( scalar( $mvh->delete( 'Name' ) ) );
	$should = "[ 'John', 'Glenn', ], ";
	result( $did eq $should, "delete( 'Name' ) returns '$did'" );
	
	$did = serialize( scalar( $mvh->fetch( 'Name' ) ) );
	$should = "undef, ";
	result( $did eq $should, "fetch( 'Name' ) returns '$did'" );

	$did = serialize( scalar( $mvh->delete( 'Name' ) ) );
	$should = "undef, ";
	result( $did eq $should, "delete( 'Name' ) returns '$did'" );

	# now we do delete_all()

	$did = serialize( scalar( $mvh->delete_all() ) );
	$should = "{ '' => [ ], 'Siblings' => [ ], 'age' => [ '18', ], 'color' => [ ], 'pets' => [ 'Dog', 'Hamster', ], 'songs' => [ 'this', 'that', 'and the other', ], }, ";
	result( $did eq $should, "delete_all() returns '$did'" );

	$did = serialize( scalar( $mvh->fetch_all() ) );
	$should = "{ }, ";
	result( $did eq $should, "fetch_all() returns '$did'" );

	$did = serialize( scalar( $mvh->delete_all() ) );
	$should = "{ }, ";
	result( $did eq $should, "delete_all() returns '$did'" );
}

######################################################################
# testing batch_new()

{
	message( "testing batch_new()" );

	my ($mvh, $did, $should);

	my @sources = (
		'',
		[],
		{},
		{ name => 'Don Smith' },
		Data::MultiValuedHash->new( 1, {
			Name => 'John',
			age => 17,
			color => 'green',
			Siblings => ['Laura', 'Andrew', 'Julia'],
			pets => ['Cat', 'Bird'],
		} ),
		{
			visible_title => "What's your name?",
			type => 'textfield',
			name => 'name',
		}, {
			visible_title => "What's the combination?",
			type => 'checkbox_group',
			name => 'words',
			'values' => ['eenie', 'meenie', 'minie', 'moe'],
			default => ['eenie', 'minie'],
		}, {
			visible_title => "What's your favorite colour?",
			type => 'popup_menu',
			name => 'color',
			'values' => ['red', 'green', 'blue', 'chartreuse'],
		}, {
			type => 'submit', 
		},	
	);
	result( @sources == 9, "there are @{[scalar(@sources)]} source records" );

	my @mvh_list = Data::MultiValuedHash->batch_new( 0, \@sources );
	result( @mvh_list == 9, "there are @{[scalar(@mvh_list)]} new objects" );
	
	my @expected = (
		"{ }, ",
		"{ }, ",
		"{ }, ",
		"{ 'name' => [ 'Don Smith', ], }, ",
		"{ 'age' => [ '17', ], 'color' => [ 'green', ], 'name' => [ 'John', ], 'pets' => [ 'Cat', 'Bird', ], 'siblings' => [ 'Laura', 'Andrew', 'Julia', ], }, ",
		"{ 'name' => [ 'name', ], 'type' => [ 'textfield', ], 'visible_title' => [ 'What's your name?', ], }, ",
		"{ 'default' => [ 'eenie', 'minie', ], 'name' => [ 'words', ], 'type' => [ 'checkbox_group', ], 'values' => [ 'eenie', 'meenie', 'minie', 'moe', ], 'visible_title' => [ 'What's the combination?', ], }, ",
		"{ 'name' => [ 'color', ], 'type' => [ 'popup_menu', ], 'values' => [ 'red', 'green', 'blue', 'chartreuse', ], 'visible_title' => [ 'What's your favorite colour?', ], }, ",
		"{ 'type' => [ 'submit', ], }, ",
	);

	foreach my $i (0..$#mvh_list) {
		$mvh = $mvh_list[$i];
		
		$did = UNIVERSAL::isa( $mvh, "Data::MultiValuedHash" );
		result( $did, "new object $i is an MVH object" );

		if( $did ) {
			$did = $mvh->ignores_case();
			result( $did == 0, "mvh$i->ignores_case() returns '$did'" );

			$did = serialize( scalar( $mvh->fetch_all() ) );
			$should = $expected[$i];
			result( $did eq $should, "mvh$i->fetch_all() returns '$did'" );
		}
	}
}

######################################################################

message( "DONE TESTING Data::MultiValuedHash" );

######################################################################

1;
	Global
`s`	Focus search bar
`?`	Bring up this help dialog
	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)
	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse
	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)