Array-Unique-0.08/000075500000000000000000000000001132533212200137535ustar00rootroot00000000000000Array-Unique-0.08/Build.PL000064400000000000000000000010211132533212200152410ustar00rootroot00000000000000use strict; use warnings; use Module::Build; use 5.006; my $builder = Module::Build->new( module_name => 'Array::Unique', license => 'perl', dist_author => 'Gabor Szabo ', #dist_abstract => 'Tie-able array that allows only unique values', create_makefile_pl => 'traditional', create_readme => 1, requires => { 'perl' => '5.006', }, build_requires => { 'Test::More' => 0.47, }, ); $builder->create_build_script(); Array-Unique-0.08/Changes000064400000000000000000000030011132533212200152400ustar00rootroot00000000000000Revision history for Perl extension Array::Unique. 0.08 2008 June 4 Mostly CPANTS gaming Change pod header to include =LICENSE Some docs cleanup Include authors tests in xt/ 0.07 2006 September 15 Add pod tests Add missing META.yml file Replace internal method Splice by _splice 0.06 2004 October 2 Fixing a bug dropping false values from the list such ase 0 and "" (Werner Weichselberger) Adding more tests. Using Module::Build 0.05 2003 October 11 0.04 2002 December - actually uploaded to CPAN on 2003.10.11 added use warnings to the released version as well. add tests with negative indexes and fix a minor problem with negative indexes in splice. Add '' in documentation to satisfy strict and warnings Change tests to use Test::More and add Test::More requirement to the makefile. Creat a new implementation from scratch that will replace all previous implementations. Added lots of new tests. Test coverage as reported by Devel::Cover is 83.3% 0.03 2002 July 27 Nothing changed inside. Added Tie::IxHash as a prequisite to the Makefile.PL file. 0.02 2002 July 26 Fix a typo in SPLICE that caused it not working at all. Add a test that would have caught this bug. Separate implementation file from the main file. Add a faster implementation using Tie::IxHash. Add more test. Improve speed by not doing a full cleanup on each 0.01 2002 July 17 First version, everything is new. Array-Unique-0.08/MANIFEST000064400000000000000000000002471132533212200151070ustar00rootroot00000000000000Changes Makefile.PL Build.PL MANIFEST README META.yml t/01regular.t t/02class.t t/03unique.t t/04false.t lib/Array/Unique.pm xt/critic.t xt/pod-coverage.t xt/pod.t Array-Unique-0.08/META.yml000064400000000000000000000007251132533212200152300ustar00rootroot00000000000000--- name: Array-Unique version: 0.08 author: - 'Gabor Szabo ' abstract: Tie-able array that allows only unique values license: perl resources: license: http://dev.perl.org/licenses/ requires: perl: 5.006 build_requires: Test::More: 0.47 provides: Array::Unique: file: lib/Array/Unique.pm version: 0.08 generated_by: Module::Build version 0.2808 meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.2.html version: 1.2 Array-Unique-0.08/Makefile.PL000064400000000000000000000006341132533212200157300ustar00rootroot00000000000000# Note: this file was auto-generated by Module::Build::Compat version 0.03 use ExtUtils::MakeMaker; WriteMakefile ( 'NAME' => 'Array::Unique', 'VERSION_FROM' => 'lib/Array/Unique.pm', 'PREREQ_PM' => { 'Test::More' => '0.47' }, 'INSTALLDIRS' => 'site', 'EXE_FILES' => [], 'PL_FILES' => {} ) ; Array-Unique-0.08/README000064400000000000000000000135401132533212200146360ustar00rootroot00000000000000NAME Array::Unique - Tie-able array that allows only unique values SYNOPSIS use Array::Unique; tie @a, 'Array::Unique'; Now use @a as a regular array. DESCRIPTION This package lets you create an array which will allow only one occurrence of any value. In other words no matter how many times you put in 42 it will keep only the first occurrence and the rest will be dropped. You use the module via tie and once you tied your array to this module it will behave correctly. Uniqueness is checked with the 'eq' operator so among other things it is case sensitive. As a side effect the module does not allow undef as a value in the array. EXAMPLES use Array::Unique; tie @a, 'Array::Unique'; @a = qw(a b c a d e f); push @a, qw(x b z); print "@a\n"; # a b c d e f x z DISCUSSION When you are collecting a list of items and you want to make sure there is only one occurrence of each item, you have several option: 1) using an array and extracting the unique elements later You might use a regular array to hold this unique set of values and either remove duplicates on each update by that keeping the array always unique or remove duplicates just before you want to use the uniqueness feature of the array. In either case you might run a function you call @a = unique_value(@a); The problem with this approach is that you have to implement the unique_value function (see later) AND you have to make sure you don't forget to call it. I would say don't rely on remembering this. There is good discussion about it in the 1st edition of the Perl Cookbook of O'Reilly. I have copied the solutions here, you can see further discussion in the book. Extracting Unique Elements from a List (Section 4.6 in the Perl Cookbook 1st ed.) # Straightforward %seen = (); @uniq = (); foreach $item (@list) [ unless ($seen{$item}) { # if we get here we have not seen it before $seen{$item} = 1; push (@uniq, $item); } } # Faster %seen = (); foreach $item (@list) { push(@uniq, $item) unless $seen{$item}++; } # Faster but different %seen; foreach $item (@list) { $seen{$item}++; } @uniq = keys %seen; # Faster and even more different %seen; @uniq = grep {! $seen{$_}++} @list; 2) using a hash Some people use the keys of a hash to keep the items and put an arbitrary value as the values of the hash: To build such a list: %unique = map { $_ => 1 } qw( one two one two three four! ); To print it: print join ", ", sort keys %unique; To add values to it: $unique{$_}=1 foreach qw( one after the nine oh nine ); To remove values: delete @unique{ qw(oh nine) }; To check if a value is there: $unique{ $value }; # which is why I like to use "1" as my value (thanks to Gaal Yahas for the above examples) There are three drawbacks I see: 1) You type more. 2) Your reader might not understand at first why did you use hash and what will be the values. 3) You lose the order. Usually non of them is critical but when I saw this the 10th time in a code I had to understand with 0 documentation I got frustrated. 3) using Array::Unique So I decided to write this module because I got frustrated by my lack of understanding what's going on in that code I mentioned. In addition I thought it might be interesting to write this and then benchmark it. Additionally it is nice to have your name displayed in bright lights all over CPAN ... or at least in a module. Array::Unique lets you tie an array to hmmm, itself (?) and makes sure the values of the array are always unique. Since writing this I am not sure if I really recommend its usage. I would say stick with the hash version and document that the variable is aggregating a unique list of values. 4) Using real SET There are modules on CPAN that let you create and maintain SETs. I have not checked any of those but I guess they just as much of an overkill for this functionality as Unique::Array. BUGS use Array::Unique; tie @a, 'Array::Unique'; @c = @a = qw(a b c a d e f b); @c will contain the same as @a AND two undefs at the end because @c you get the same length as the right most list. TODO Test: Change size of the array Elements with false values ('', '0', 0) splice: splice @a; splice @a, 3; splice @a, -3; splice @a, 3, 5; splice @a, 3, -5; splice @a, -3, 5; splice @a, -3, -5; splice @a, ?, ?, @b; Benchmark speed Add faster functions that don't check uniqueness so if I know part of the data that comes from a unique source then I can speed up the process, In short shoot myself in the leg. Enable optional compare with other functions Write even better implementations. AUTHOR Gabor Szabo LICENSE Copyright (C) 2002-2008 Gabor Szabo All rights reserved. http://www.pti.co.il/ You may distribute under the terms of either the GNU General Public License or the Artistic License, as specified in the Perl README file. No WARRANTY whatsoever. CREDITS Thanks for suggestions and bug reports to Szabo Balazs (dLux) Shlomo Yona Gaal Yahas Jeff 'japhy' Pinyan Werner Weichselberger VERSION Version: 0.08 Date: 2008 June 04 Array-Unique-0.08/lib/000075500000000000000000000000001132533212200145215ustar00rootroot00000000000000Array-Unique-0.08/lib/Array/000075500000000000000000000000001132533212200155775ustar00rootroot00000000000000Array-Unique-0.08/lib/Array/Unique.pm000064400000000000000000000206321132533212200174060ustar00rootroot00000000000000package Array::Unique; use 5.006; use strict; use warnings; use Carp; our $VERSION = '0.08'; # Strips out any duplicate values (leaves the first occurrence # of every duplicated value and drops the later occurrences). # Removes all undef values. sub unique { my $self = shift; # self or class my %seen; my @unique = grep defined $_ && !$seen{$_}++, @_; # based on the Cookbook 1st edition and on suggestion by Jeff 'japhy' Pinyan # fixed by Werner Weichselberger } sub TIEARRAY { my $class = shift; my $self = { array => [], hash => {}, }; bless $self, $class; } sub CLEAR { my $self = shift; $self->{array} = []; $self->{hash} = {}; } sub EXTEND {} sub STORE { my ($self, $index, $value) = @_; $self->SPLICE($index, 1, $value); } sub FETCHSIZE { my $self = shift; return scalar @{$self->{array}}; } sub FETCH { my ($self, $index) = @_; ${$self->{array}}[$index]; } sub STORESIZE { my $self = shift; my $size = shift; # We cannot enlarge the array as the values would be undef # But we can make it smaller # if ($self->FETCHSIZE > $size) { # $self->{->_splice($size); # } $#{$self->{array}} = $size-1; return $size; } sub SPLICE { my $self = shift; my $offset = shift; my $length = shift; # reset length value to positive (this is done by the normal splice too) if (defined $length and $length < 0) { #$length = @{$self->{array}} + $length; $length += $self->FETCHSIZE - $offset; } # reset offset to positive (this is done by the normal splice too) if (defined $offset and $offset < 0) { $offset += $self->FETCHSIZE; } if (defined $offset and $offset > $self->FETCHSIZE) { $offset = $self->FETCHSIZE; # should give a warning like this: splice() offset past end of array # if this was really a splice (and warning set) but no warning if this # was an assignment to a high index. } # my @s = @{$self->{array}}[$offset..$offset+$length]; # the old values to be returned my @original; # if (defined $length) { @original = $self->_splice($self->{array}, $offset, $length, @_); # } elsif (defined $offset) { # @original = $self->_splice($self->{array}, $offset); # } else { # @original = $self->_splice($self->{array}); # } return @original; } sub PUSH { my $self = shift; $self->SPLICE($self->FETCHSIZE, 0, @_); # while (my $value = shift) { # $self->STORE($self->FETCHSIZE+1, $value); # } return $self->FETCHSIZE; } sub POP { my $self = shift; ($self->SPLICE(-1))[0]; } sub SHIFT { my $self = shift; # #($self->{array})[0]; ($self->SPLICE(0,1))[0]; } sub UNSHIFT { my $self = shift; $self->SPLICE(0,0,@_); } sub _splice { my $self = shift; my $a = shift; my $offset = shift; my $length = shift; my @original; if (defined $length) { @original = splice(@$a, $offset, $length, @_); } elsif (defined $offset) { @original = splice(@$a, $offset); } else { @original = splice(@$a); } @$a = $self->unique(@$a); return @original; } =head1 NAME Array::Unique - Tie-able array that allows only unique values =head1 SYNOPSIS use Array::Unique; tie @a, 'Array::Unique'; Now use @a as a regular array. =head1 DESCRIPTION This package lets you create an array which will allow only one occurrence of any value. In other words no matter how many times you put in 42 it will keep only the first occurrence and the rest will be dropped. You use the module via tie and once you tied your array to this module it will behave correctly. Uniqueness is checked with the 'eq' operator so among other things it is case sensitive. As a side effect the module does not allow undef as a value in the array. =head1 EXAMPLES use Array::Unique; tie @a, 'Array::Unique'; @a = qw(a b c a d e f); push @a, qw(x b z); print "@a\n"; # a b c d e f x z =head1 DISCUSSION When you are collecting a list of items and you want to make sure there is only one occurrence of each item, you have several option: =over 4 =item 1) using an array and extracting the unique elements later You might use a regular array to hold this unique set of values and either remove duplicates on each update by that keeping the array always unique or remove duplicates just before you want to use the uniqueness feature of the array. In either case you might run a function you call @a = unique_value(@a); The problem with this approach is that you have to implement the unique_value function (see later) AND you have to make sure you don't forget to call it. I would say don't rely on remembering this. There is good discussion about it in the 1st edition of the Perl Cookbook of O'Reilly. I have copied the solutions here, you can see further discussion in the book. Extracting Unique Elements from a List (Section 4.6 in the Perl Cookbook 1st ed.) # Straightforward %seen = (); @uniq = (); foreach $item (@list) [ unless ($seen{$item}) { # if we get here we have not seen it before $seen{$item} = 1; push (@uniq, $item); } } # Faster %seen = (); foreach $item (@list) { push(@uniq, $item) unless $seen{$item}++; } # Faster but different %seen; foreach $item (@list) { $seen{$item}++; } @uniq = keys %seen; # Faster and even more different %seen; @uniq = grep {! $seen{$_}++} @list; =item 2) using a hash Some people use the keys of a hash to keep the items and put an arbitrary value as the values of the hash: To build such a list: %unique = map { $_ => 1 } qw( one two one two three four! ); To print it: print join ", ", sort keys %unique; To add values to it: $unique{$_}=1 foreach qw( one after the nine oh nine ); To remove values: delete @unique{ qw(oh nine) }; To check if a value is there: $unique{ $value }; # which is why I like to use "1" as my value (thanks to Gaal Yahas for the above examples) There are three drawbacks I see: =over 4 =item 1) You type more. =item 2) Your reader might not understand at first why did you use hash and what will be the values. =item 3) You lose the order. =back Usually non of them is critical but when I saw this the 10th time in a code I had to understand with 0 documentation I got frustrated. =item 3) using Array::Unique So I decided to write this module because I got frustrated by my lack of understanding what's going on in that code I mentioned. In addition I thought it might be interesting to write this and then benchmark it. Additionally it is nice to have your name displayed in bright lights all over CPAN ... or at least in a module. Array::Unique lets you tie an array to hmmm, itself (?) and makes sure the values of the array are always unique. Since writing this I am not sure if I really recommend its usage. I would say stick with the hash version and document that the variable is aggregating a unique list of values. =item 4) Using real SET There are modules on CPAN that let you create and maintain SETs. I have not checked any of those but I guess they just as much of an overkill for this functionality as Unique::Array. =back =head1 BUGS use Array::Unique; tie @a, 'Array::Unique'; @c = @a = qw(a b c a d e f b); @c will contain the same as @a AND two undefs at the end because @c you get the same length as the right most list. =head1 TODO Test: Change size of the array Elements with false values ('', '0', 0) splice: splice @a; splice @a, 3; splice @a, -3; splice @a, 3, 5; splice @a, 3, -5; splice @a, -3, 5; splice @a, -3, -5; splice @a, ?, ?, @b; Benchmark speed Add faster functions that don't check uniqueness so if I know part of the data that comes from a unique source then I can speed up the process, In short shoot myself in the leg. Enable optional compare with other functions Write even better implementations. =head1 AUTHOR Gabor Szabo =head1 LICENSE Copyright (C) 2002-2008 Gabor Szabo All rights reserved. http://www.pti.co.il/ You may distribute under the terms of either the GNU General Public License or the Artistic License, as specified in the Perl README file. No WARRANTY whatsoever. =head1 CREDITS Thanks for suggestions and bug reports to Szabo Balazs (dLux) Shlomo Yona Gaal Yahas Jeff 'japhy' Pinyan Werner Weichselberger =head1 VERSION Version: 0.08 Date: 2008 June 04 =cut 1; Array-Unique-0.08/t/000075500000000000000000000000001132533212200142165ustar00rootroot00000000000000Array-Unique-0.08/t/01regular.t000064400000000000000000000145671132533212200162220ustar00rootroot00000000000000 # For testing the regular array behaviour of the module. # Except that this version does NOT allow undef values in the array # so if you put a value at an index which would leave undefs in # between the new value is appended to the end of the array # The tests in this file should include only unique values so they # whould work even with a regular array (except of the undefs). # TODO: # this returns strange, (undefined ?) value use strict; use warnings; use Test::More; #my @modes = (undef, 'Std', 'IxHash'); #my @modes = ('Hash'); #my @modes = ('default', 'standard'); my @modes = ('default', 'standard', 'unique'); # default = what we have in Perl # standard = using Array::Std, # unique = Array::Unique plan tests => (50 * @modes); #plan tests => (47); foreach my $m (@modes) { unit_test($m); } exit; ####################################################### sub unit_test { my $mode = shift; my @a; my $o; my @c; SKIP: { skip 'needed for unique only', 3 unless $mode eq 'unique'; eval { require Array::Unique; }; is($@, '', 'Load module Array::Unique'); die $@ if $@; eval {$o = tie @a, 'Array::Unique';}; is($@, '', 'tie-ing an array'); die $@ if $@; is(ref $o, 'Array::Unique', 'received Array::Unique object'); } SKIP: { skip 'needed for default only', 1 unless $mode eq 'standard'; require Tie::Array; $o = tie @a, 'Tie::StdArray'; is(ref $o, 'Tie::StdArray', 'received a Tie::StdArray object'); } # --------------------------------------------------- # create a simple array # --------------------------------------------------- @c=@a=qw(a b c d); is(@a, 4, 'length is really 5'); is_deeply(\@a, [qw(a b c d)], 'Create an array with simple assignement of 4 elements'); is_deeply(\@c, [qw(a b c d)], 'create array returns the same array'); @c=@a=(); is(@a, 0, 'set empty array'); is(@c, 0, 'set empty array with returned value'); @a=qw(a b c d); # --------------------------------------------------- # fetch the value of a specific element in the array # --------------------------------------------------- is($a[0], "a", 'fetch the value of element 0'); is($a[2], "c", 'fetch the value of element 2'); is($a[-1], "d", 'fetch the value of element -1'); is($a[-2], "c", 'fetch the value of element -2'); # --------------------------------------------------- # set a value in a specific index # --------------------------------------------------- $a[@a] = 'e'; is_deeply(\@a, [qw(a b c d e)], 'set a value at an index higher than size of array'); $a[1] = 'x'; is_deeply(\@a, [qw(a x c d e)], 'set value in an existing index'); $a[0] = 'z'; is_deeply(\@a, [qw(z x c d e)], 'set value in an existing index (0)'); $a[-1] = "p"; is_deeply(\@a, [qw(z x c d p)], 'Set the value of negative indexes, -1'); $a[-2] = "y"; is_deeply(\@a, [qw(z x c y p)], 'Set the value of negative indexes -2'); $a[@a+2] = 'q'; # this is not even the normal behavior: SKIP: { skip 'only the standard behavior', 2 unless $mode eq 'default' or $mode eq 'standard'; is(@a, 8, 'lenght includes undefs in the middle'); is_deeply(\@a, ['z', 'x', 'c', 'y', 'p', undef, undef, 'q'], 'set value - with a break in the indexes'); } SKIP: { skip 'behavior only in unique module', 2 unless $mode eq 'unique'; is(@a, 6, 'lenght does not includ undefs in the middle as they are removed'); is_deeply(\@a, ['z', 'x', 'c', 'y', 'p', 'q'], 'set value - with a break in the indexes'); } # --------------------------------------------------- # change the size of the array # check the size # --------------------------------------------------- my $t = $#a = 3; is($t, 3, 'set length returns the correct value'); is($#a, 3, 'length was set correctly'); is(@a, 4, 'number of elements is correct'); is_deeply(\@a, [qw(z x c y)], 'array shortened correctly'); $#a=0; is_deeply(\@a, ['z'], 'set length of 0'); # --------------------------------------------------- # push # --------------------------------------------------- @a = qw(a b c d e); my $length = @a; is_deeply([push(@a, 'f')], [$length+1], 'push one value on the array returns new size'); is_deeply(\@a, [qw(a b c d e f)], 'push successfull'); #print "DEBUG: '@a'\n"; is_deeply([push(@a, 'g', 'h')], [$length+3], 'push returns new length'); is_deeply(\@a, [qw(a b c d e f g h)], 'push successfull'); # --------------------------------------------------- # pop # --------------------------------------------------- my $p = pop(@a); is($p, "h", 'pop last element works'); is_deeply(\@a, [qw(a b c d e f g)], 'remaining array after pop is correct'); # --------------------------------------------------- # shift # --------------------------------------------------- my $s = shift @a; is($s, "a", 'shift first element works'); is_deeply(\@a, [qw(b c d e f g)], 'array is correct after shift'); # --------------------------------------------------- # unshift # --------------------------------------------------- is_deeply([unshift @a, 'z'],[7] , 'unshift returns new length correctly'); is_deeply(\@a, [qw(z b c d e f g)], 'unshift works correctly with one value'); # --------------------------------------------------- # splice # --------------------------------------------------- my @b = splice(@a, 2, 3); is_deeply(\@b, [qw(c d e)], 'splice returns the cut out part'); is_deeply(\@a, [qw(z b f g)], 'splice leaves the correct array'); @b = splice(@a, 2, 1, qw(x y w)); is_deeply(\@b, [qw(f)], 'splice retursn the cut out part'); is_deeply(\@a, [qw(z b x y w g)], 'splice - replace was successfull'); # --------------------------------------------------- # splice with negative values # --------------------------------------------------- @b = splice(@a, -1); is_deeply(\@b, [qw(g)], 'cut out the last element with -1'); is_deeply(\@a, [qw(z b x y w)],'remaining all but the last element'); @a = qw(a b c d e f g h i j k); @b = splice (@a, -5, 3, qw(z)); is_deeply(\@b, [qw(g h i)], 'cut out a few elements with negative index'); is_deeply(\@a, [qw(a b c d e f z j k)], 'inserted elements after cut out'); @b = splice(@a, 1, -1); is_deeply(\@a, [qw(a k)], 'negative length'); is_deeply(\@b, [qw(b c d e f z j)], 'negative length'); @b = @a = (qw(a b c d), qw(x y z)); is_deeply(\@a, [qw(a b c d x y z)], 'pass value of just created array'); is_deeply(\@b, [qw(a b c d x y z)], 'pass value of just created array'); my $b = @a = (qw(a b c d), qw(x y z)); is($b, 7, 'pass scalar value of created array'); } Array-Unique-0.08/t/02class.t000064400000000000000000000007131132533212200156530ustar00rootroot00000000000000 # testing class methods use strict; use warnings; use Test::More; plan tests => 4; use Array::Unique; is_deeply([Array::Unique->unique(qw(a s d f g))], [qw(a s d f g)], 'compare unique arrays'); is_deeply([Array::Unique->unique(qw(a s d f a))], [qw(a s d f)], 'one extra item '); is_deeply([Array::Unique->unique(qw(a b b a))], [qw(a b)], 'two pairs'); is_deeply([Array::Unique->unique('a', 'b', undef, 'b', undef, 'a', undef)], [qw(a b)], 'undefs'); Array-Unique-0.08/t/03unique.t000064400000000000000000000106511132533212200160570ustar00rootroot00000000000000 # TODO: # return @u = (@a, @b); # this returns strange, (undefined ?) value use strict; use warnings; use Test::More; plan tests => (29); # --------------------------------------------------- # Check if module is loading # --------------------------------------------------- eval { require Array::Unique; }; is($@, '', 'Load module Array::Unique'); die $@ if $@; # --------------------------------------------------- # New instance creation # --------------------------------------------------- my @a; my $o; my @b; # help variables my $b; eval {$o = tie @a, 'Array::Unique';}; is($@, '', 'tie-ing an array'); die $@ if $@; @b = @a = qw(a b c a d a b q a); is(@a, 5, 'length is correct'); is_deeply(\@a, [qw(a b c d q)], 'create an array where there were dupplicates'); is($a[0], "a", 'fetch the value of element 0'); is($a[3], "d", 'fetch the value of element 3'); is($a[10], undef, 'fetch the value of too high index'); is($a[-1], "q", 'fetch the value of element -1'); is($a[-2], "d", 'fetch the value of element -2'); TODO: { local $TODO = 'transferes the length of the original list and we get undefs at the end'; is(@b, 5, 'length is correct'); is_deeply(\@b, [qw(a b c d q)], 'transfere assignment'); } @b=@a; is(@b, 5, 'length is correct'); $b = $a[4] = 'b'; is_deeply(\@a, [qw(a b c d)], 'replace a value with an existing value'); TODO: { local $TODO='passing the new value not the one received'; is($b, 'b', 'assigned value gets transfered'); } $b = $a[1] = 'x'; is_deeply(\@a, [qw(a x c d)], 'replace a value with a new value'); is($b, 'x', 'assigned value gets transfered'); $b = $a[1] = 'd'; is_deeply(\@a, [qw(a d c)], 'replace a value with an existing value'); is($b, 'd', 'assigned value gets transfered'); $b = $a[1] = 'd'; is_deeply(\@a, [qw(a d c)], 'replace a value in the same location'); is($b, 'd', 'assigned value gets transfered'); $b = $a[6] = 'a'; is_deeply(\@a, [qw(a d c)], ''); TODO: { local $TODO='passing the new value not the one received'; is($b, 'a', 'assigned value gets transfered'); } # --------------------------------------------------- # Set the value of negative indexes # --------------------------------------------------- @a = qw(a b c d e); $b = $a[-1] = "a"; is_deeply(\@a, [qw(a b c d)], 'Set the value of negative indexes, -1'); TODO: { local $TODO='passing the new value not the one received'; is($b, 'a', 'assigned value gets transfered'); } $b = $a[-2] = "d"; is_deeply(\@a, [qw(a b d)], 'Set the value of negative indexes -2'); is($b, 'd', 'assigned value gets transfered'); $#a=1; is_deeply(\@a, [qw(a b)], 'change the size of the array'); is($#a, 1, 'highest index corect'); is(@a, 2, 'size correct'); =pod # --------------------------------------------------- # push # --------------------------------------------------- push @a, qw; ok("@a" eq "a b"); #print "DEBUG: '@a'\n"; push @a, 'c', 'd'; ok("@a" eq "a b c d"); #print "DEBUG: @a\n"; push @a, qw(x y d z a); ok("@a" eq "a b c d x y z"); #print "DEBUG: @a\n"; =cut TODO: { local $TODO = 'wait'; } __END__ # --------------------------------------------------- # splice # --------------------------------------------------- my @b = splice(@a, 2, 3); ok("@b" eq "c d x"); #print "DEBUG: '@b'\n"; ok("@a" eq "a b y z"); #print "DEBUG: '@a'\n"; @b = splice(@a, 2, 1, qw(z a u)); ok("@b" eq "y"); #print "DEBUG: '@b'\n"; ok("@a" eq "a b z u"); #print "DEBUG: '@a'\n"; # --------------------------------------------------- # splice with negative values # --------------------------------------------------- @a = qw(a b c d e f g h i j k l); @b = splice (@a, -1); is_deeply(\@b, [qw(l)], ''); #print "DEBUG: '@b'\n"; is_deeply(\@a, [qw(a b c d e f g h i j k)],''); #print "DEBUG: '@a'\n"; @b = splice (@a, -7, 4, qw(z)); is_deeply(\@b, [qw(e f g h)], ''); #print "DEBUG: '@b'\n"; is_deeply(\@a, [qw(a b c d z i j k)], ''); #print "DEBUG: '@a'\n"; # --------------------------------------------------- # unshift # --------------------------------------------------- @a = qw(a b z u); unshift @a, qw(d a w); is_deeply(\@a, [qw(d a w b z u)], ''); #print "DEBUG: '@a'\n"; # --------------------------------------------------- # pop # --------------------------------------------------- my $p = pop(@a); is($p, "u", ''); is_deeply(\@a, [qw(d a w b z)], ''); # --------------------------------------------------- # shift # --------------------------------------------------- my $s = shift @a; is($s, "d", ''); is_deeply(\@a, [qw(a w b z)], ''); Array-Unique-0.08/t/04false.t000064400000000000000000000003111132533212200156340ustar00rootroot00000000000000use strict; use warnings; use Test::More "no_plan"; use Array::Unique; tie my @a, 'Array::Unique'; push @a, (1, 0, "x", ""); is_deeply([1, 0, "x", ""], \@a, "false but defined elements are kept"); Array-Unique-0.08/xt/000075500000000000000000000000001132533212200144065ustar00rootroot00000000000000Array-Unique-0.08/xt/critic.t000064400000000000000000000003601132533212200160470ustar00rootroot00000000000000use strict; use warnings; use Test::More; eval { require Test::Perl::Critic; import Test::Perl::Critic; }; plan skip_all => 'Test::Perl::Critic required to criticise code' if $@; #all_critic_ok('blib'); all_critic_ok('blib', 't'); Array-Unique-0.08/xt/pod-coverage.t000064400000000000000000000002601132533212200171440ustar00rootroot00000000000000use Test::More; eval 'use Test::Pod::Coverage'; plan skip_all => 'Needs Test::Pod::Coverage' if $@; #all_pod_coverage_ok(); plan tests => 1; pod_coverage_ok('Array::Unique'); Array-Unique-0.08/xt/pod.t000064400000000000000000000001451132533212200153550ustar00rootroot00000000000000use Test::More; eval "use Test::Pod"; plan skip_all => 'Needs Test::Pod' if $@; all_pod_files_ok();