Hash-Util/t/Util.t

56 my %hash = (foo => 42, bar => 23, locked => 'yep');
57 lock_keys(%hash);
58 eval { $hash{baz} = 99; };
61 is( $hash{bar}, 23, '$hash{bar} == 23' );
62 ok( !exists $hash{baz},'!exists $hash{baz}' );
64 delete $hash{bar};
65 ok( !exists $hash{bar},'!exists $hash{bar}' );
66 $hash{bar} = 69;
67 is( $hash{bar}, 69 ,'$hash{bar} == 69');
69 eval { () = $hash{i_dont_exist} };
73 lock_value(%hash, 'locked');
74 eval { print "# oops" if $hash{four} };
78 eval { $hash{"\x{2323}"} = 3 };
82 eval { delete $hash{locked} };
85 eval { $hash{locked} = 42; };
88 is( $hash{locked}, 'yep', '$hash{locked} is yep' );
90 eval { delete $hash{I_dont_exist} };
94 ok( !exists $hash{I_dont_exist},'!exists $hash{I_dont_exist}' );
96 unlock_keys(%hash);
97 $hash{I_dont_exist} = 42;
98 is( $hash{I_dont_exist}, 42,    'unlock_keys' );
100 eval { $hash{locked} = 42; };
103 eval { delete $hash{locked} },
106 unlock_value(%hash, 'locked');
107 $hash{locked} = 42;
108 is( $hash{locked}, 42,  'unlock_value' );
112     my %hash = ( foo => 42, locked => 23 );
114     lock_keys(%hash);
115     eval { %hash = ( wubble => 42 ) };  # we know this will bomb
117     unlock_keys(%hash);
121     my %hash = (KEY => 'val', RO => 'val');
122     lock_keys(%hash);
123     lock_value(%hash, 'RO');
125     eval { %hash = (KEY => 1) };
131     my %hash = (KEY => 1, RO => 2);
132     lock_keys(%hash);
133     eval { %hash = (KEY => 1, RO => 2) };
138     my %hash = ();
139     lock_keys(%hash, qw(foo bar));
140     is( keys %hash, 0,  'lock_keys() w/keyset shouldnt add new keys' );
141     $hash{foo} = 42;
142     is( keys %hash, 1, '1 element in hash' );
143     eval { $hash{wibble} = 42 };
147     unlock_keys(%hash);
148     eval { $hash{wibble} = 23; };
153     my %hash = (foo => 42, bar => undef, baz => 0);
154     lock_keys(%hash, qw(foo bar baz up down));
155     is( keys %hash, 3,   'lock_keys() w/keyset didnt add new keys' );
156     is_deeply( \%hash, { foo => 42, bar => undef, baz => 0 },'is_deeply' );
158     eval { $hash{up} = 42; };
161     eval { $hash{wibble} = 23 };
167     my %hash = (foo => 42, bar => undef);
168     eval { lock_keys(%hash, qw(foo baz)); };
174     my %hash = (foo => 42, bar => 23);
175     lock_hash( %hash );
176     ok( hashref_locked( \%hash ), 'hashref_locked' );
177     ok( hash_locked( %hash ), 'hash_locked' );
179     ok( Internals::SvREADONLY(%hash),'Was locked %hash' );
180     ok( Internals::SvREADONLY($hash{foo}),'Was locked $hash{foo}' );
181     ok( Internals::SvREADONLY($hash{bar}),'Was locked $hash{bar}' );
183     unlock_hash ( %hash );
184     ok( hashref_unlocked( { %hash } ), 'hashref_unlocked' );
185     ok( hash_unlocked( %hash ), 'hash_unlocked' );
187     ok( !Internals::SvREADONLY(%hash),'Was unlocked %hash' );
188     ok( !Internals::SvREADONLY($hash{foo}),'Was unlocked $hash{foo}' );
189     ok( !Internals::SvREADONLY($hash{bar}),'Was unlocked $hash{bar}' );
193     my %hash = (foo => 42, bar => 23);
194     ok( ! hashref_locked( { %hash } ), 'hashref_locked negated' );
195     ok( ! hash_locked( %hash ), 'hash_locked negated' );
197     lock_hash( %hash );
198     ok( ! hashref_unlocked( \%hash ), 'hashref_unlocked negated' );
199     ok( ! hash_unlocked( %hash ), 'hash_unlocked negated' );
212     my %hash;
214     lock_keys(%hash, 'first');
216     is (scalar keys %hash, 0, "place holder isn't a key");
217     $hash{first} = 1;
218     is (scalar keys %hash, 1, "we now have a key");
219     delete $hash{first};
220     is (scalar keys %hash, 0, "now no key");
222     unlock_keys(%hash);
224     $hash{interregnum} = 1.5;
225     is (scalar keys %hash, 1, "key again");
226     delete $hash{interregnum};
227     is (scalar keys %hash, 0, "no key again");
229     lock_keys(%hash, 'second');
231     is (scalar keys %hash, 0, "place holder isn't a key");
233     eval {$hash{zeroeth} = 0};
237     eval {$hash{first} = -1};
241     is (scalar keys %hash, 0, "and therefore there are no keys");
242     $hash{second} = 1;
243     is (scalar keys %hash, 1, "we now have just one key");
244     delete $hash{second};
245     is (scalar keys %hash, 0, "back to zero");
247     unlock_keys(%hash); # We have deliberately left a placeholder.
249     $hash{void} = undef;
250     $hash{nowt} = undef;
252     is (scalar keys %hash, 2, "two keys, values both undef");
254     lock_keys(%hash);
256     is (scalar keys %hash, 2, "still two keys after locking");
258     eval {$hash{second} = -1};
263     is ($hash{void}, undef,
265     is ($hash{nowt}, undef,
327     my %hash;
328     lock_hash(%hash);
329     %hash = ();
330     ok(keys(%hash) == 0, 'clear empty lock_hash() hash');
333     my %hash;
334     lock_keys(%hash);
335     %hash = ();
336     ok(keys(%hash) == 0, 'clear empty lock_keys() hash');
341     my %hash = (key=>__PACKAGE__);
342     lock_hash(%hash);
343     eval { delete $hash{key} };
346     eval { %hash = () };
369 	my %hash;
370 	$hash{a} = $a;
373 	lock_keys(%hash) if $state;
378 	delete $hash{a};
380 	$hash{a} = undef;
382 	%hash = ();
387     my %hash = map {$_,$_} qw(fwiffffff foosht teeoo);
388     lock_keys(%hash);
389     delete $hash{fwiffffff};
390     is (scalar keys %hash, 2,"Count of keys after delete on locked hash");
391     unlock_keys(%hash);
392     is (scalar keys %hash, 2,"Count of keys after unlock");
394     my ($first, $value) = each %hash;
395     is ($hash{$first}, $value, "Key has the expected value before the lock");
396     lock_keys(%hash);
397     is ($hash{$first}, $value, "Key has the expected value after the lock");
399     my ($second, $v2) = each %hash;
401     is ($hash{$first}, $value, "Still correct after iterator advances");
402     is ($hash{$second}, $v2, "Other key has the expected value");
415     my %hash=map { $_ => 1 } qw( a b c d e f);
416     delete $hash{c};
417     lock_keys(%hash);
418     ok(Internals::SvREADONLY(%hash),'lock_keys DDS/t 1');
419     delete @hash{qw(b e)};
420     my @hidden=sort(hidden_keys(%hash));
421     my @legal=sort(legal_keys(%hash));
422     my @keys=sort(keys(%hash));
429     my %hash=(0..9);
430     lock_keys(%hash);
431     ok(Internals::SvREADONLY(%hash),'lock_keys DDS/t 2');
432     Hash::Util::unlock_keys(%hash);
433     ok(!Internals::SvREADONLY(%hash),'unlock_keys DDS/t 2');
436     my %hash=(0..9);
437     lock_keys(%hash,keys(%hash),'a'..'f');
438     ok(Internals::SvREADONLY(%hash),'lock_keys args DDS/t');
439     my @hidden=sort numbers_first hidden_keys(%hash);
440     my @legal=sort numbers_first legal_keys(%hash);
441     my @keys=sort numbers_first keys(%hash);
447     my %hash=map { $_ => 1 } qw( a b c d e f);
448     delete $hash{c};
449     lock_ref_keys(\%hash);
450     ok(Internals::SvREADONLY(%hash),'lock_ref_keys DDS/t');
451     delete @hash{qw(b e)};
452     my @hidden=sort(hidden_keys(%hash));
453     my @legal=sort(legal_keys(%hash));
454     my @keys=sort(keys(%hash));
461     my %hash=(0..9);
462     lock_ref_keys(\%hash,keys %hash,'a'..'f');
463     ok(Internals::SvREADONLY(%hash),'lock_ref_keys args DDS/t');
464     my @hidden=sort numbers_first hidden_keys(%hash);
465     my @legal=sort numbers_first legal_keys(%hash);
466     my @keys=sort numbers_first keys(%hash);
472     my %hash=(0..9);
473     lock_ref_keys_plus(\%hash,'a'..'f');
474     ok(Internals::SvREADONLY(%hash),'lock_ref_keys_plus args DDS/t');
475     my @hidden=sort numbers_first hidden_keys(%hash);
476     my @legal=sort numbers_first legal_keys(%hash);
477     my @keys=sort numbers_first keys(%hash);
483     my %hash=(0..9, 'a' => 'alpha');
484     lock_ref_keys_plus(\%hash,'a'..'f');
485     ok(Internals::SvREADONLY(%hash),'lock_ref_keys_plus args overlap');
486     my @hidden=sort numbers_first hidden_keys(%hash);
487     my @legal=sort numbers_first legal_keys(%hash);
488     my @keys=sort numbers_first keys(%hash);
494     my %hash=(0..9);
495     lock_keys_plus(%hash,'a'..'f');
496     ok(Internals::SvREADONLY(%hash),'lock_keys_plus args DDS/t');
497     my @hidden=sort numbers_first hidden_keys(%hash);
498     my @legal=sort numbers_first legal_keys(%hash);
499     my @keys=sort numbers_first keys(%hash);
505     my %hash=(0..9, 'a' => 'alpha');
506     lock_keys_plus(%hash,'a'..'f');
507     ok(Internals::SvREADONLY(%hash),'lock_keys_plus args overlap non-ref');
508     my @hidden=sort numbers_first hidden_keys(%hash);
509     my @legal=sort numbers_first legal_keys(%hash);
510     my @keys=sort numbers_first keys(%hash);
517     my %hash = ('a'..'f');
521     lock_keys(%hash, @lock);
522     my $ref = all_keys(%hash, @keys, @ph);
527     ok(ref $ref eq ref \%hash && $ref == \%hash,
535     my %hash = (
541     lock_hash_recurse(%hash);
542     ok( hash_locked(%hash),
544     ok( hash_locked(%{$hash{d}}),
546     ok( ! hash_locked(%{$hash{c}[1]}),
549     unlock_hash_recurse(%hash);
550     ok( hash_unlocked(%hash),
552     ok( hash_unlocked(%{$hash{d}}),
556         eval { $hash{d} = { theta => 'kappa' }; };
560     ok( hash_unlocked(%{$hash{c}[1]}),
566     my %hash = (
572     Hash::Util::lock_hashref_recurse(\%hash);
573     ok( hash_locked(%hash),
575     ok( hash_locked(%{$hash{d}}),
577     ok( ! hash_locked(%{$hash{c}[1]}),
580     Hash::Util::unlock_hashref_recurse(\%hash);
581     ok( hash_unlocked(%hash),
583     ok( hash_unlocked(%{$hash{d}}),
587         eval { $hash{d} = { theta => 'kappa' }; };
591     ok( hash_unlocked(%{$hash{c}[1]}),