Fix typos (spelling errors) in t/*.

# New Ticket Created by  (Peter J. Acklam)
# Please include the string:  [perl #81916]
# in the subject line of all future correspondence about this issue.
# <URL: http://rt.perl.org/rt3/Ticket/Display.html?id=81916 >

21 files changed, 26 insertions, 26 deletions

diff --git a/t/op/attrs.t b/t/op/attrs.t
index a8bcd6f455..d568af6b2f 100644
--- a/t/op/attrs.t
+++ b/t/op/attrs.t
@@ -201,7 +201,7 @@ ok !defined(attributes::get(\PVBM)),
     'PVBMs don\'t segfault attributes::get';
 
 {
-    #  [perl #49472] Attributes + Unkown Error
+    #  [perl #49472] Attributes + Unknown Error
     eval '
 	use strict;
 	sub MODIFY_CODE_ATTRIBUTE{}
diff --git a/t/op/dbm.t b/t/op/dbm.t
index 24033703ba..c9add50140 100644
--- a/t/op/dbm.t
+++ b/t/op/dbm.t
@@ -42,7 +42,7 @@ EOC
 
 $prog =~ s/\@\@\@\@/$filename/;
 
-fresh_perl_is("require AnyDBM_File;\n$prog", 'ok', {}, 'explict require');
+fresh_perl_is("require AnyDBM_File;\n$prog", 'ok', {}, 'explicit require');
 fresh_perl_is($prog, 'ok', {}, 'implicit require');
 
 $prog = <<'EOC';
diff --git a/t/op/eval.t b/t/op/eval.t
index a1c1c1a94c..5ef30096c8 100644
--- a/t/op/eval.t
+++ b/t/op/eval.t
@@ -500,7 +500,7 @@ print "ok $test # length of \$@ after eval\n"; $test++;
 print "not " if (length $@ != 0);
 print "ok $test # length of \$@ after eval\n"; $test++;
 
-# Check if eval { 1 }; compeltly resets $@
+# Check if eval { 1 }; completely resets $@
 if (eval "use Devel::Peek; 1;") {
   $tempfile = tempfile();
   $outfile = tempfile();
@@ -540,10 +540,10 @@ END_EVAL_TEST
 
    my $ok = runperl(progfile => $tempfile);
    print "not " unless $ok;
-   print "ok $test # eval { 1 } completly resets \$@\n";
+   print "ok $test # eval { 1 } completely resets \$@\n";
 }
 else {
-  print "ok $test # skipped - eval { 1 } completly resets \$@\n";
+  print "ok $test # skipped - eval { 1 } completely resets \$@\n";
 }
 $test++;
 
diff --git a/t/op/exec.t b/t/op/exec.t
index 73e9a9c4a8..fb0b104f83 100644
--- a/t/op/exec.t
+++ b/t/op/exec.t
@@ -25,7 +25,7 @@ if ($^O eq 'VMS') {
 }
 
 
-# supress VMS whinging about bad execs.
+# suppress VMS whinging about bad execs.
 use vmsish qw(hushed);
 
 $| = 1;				# flush stdout
diff --git a/t/op/grep.t b/t/op/grep.t
index 456b6c5c17..9087f2c4a7 100644
--- a/t/op/grep.t
+++ b/t/op/grep.t
@@ -203,7 +203,7 @@ plan( tests => 61 );
 }
 
 {
-    # This shouldn't loop indefinitively.
+    # This shouldn't loop indefinitely.
     my @empty = map { while (1) {} } ();
     cmp_ok("@empty", 'eq', '', 'staying alive');
 }
diff --git a/t/op/gv.t b/t/op/gv.t
index e9fde9d757..c1d5f8304e 100644
--- a/t/op/gv.t
+++ b/t/op/gv.t
@@ -366,7 +366,7 @@ is (ref $::{ga_shloip}, 'SCALAR', "Export of proxy constant as is");
 is (ref $::{oonk}, 'SCALAR', "Export doesn't affect original");
 is (eval 'ga_shloip', "Value", "Constant has correct value");
 is (ref $::{ga_shloip}, 'SCALAR',
-    "Inlining of constant doesn't change represenatation");
+    "Inlining of constant doesn't change representation");
 
 delete $::{ga_shloip};
 
@@ -566,7 +566,7 @@ foreach my $value ([1,2,3], {1=>2}, *STDOUT{IO}, \&ok, *STDOUT{FORMAT}) {
     $::{BONK} = \"powie";
     *{"BONK"} = \&{"BONK"};
     eval 'is(BONK(), "powie",
-             "Assigment works when glob created midway (bug 45607)"); 1'
+             "Assignment works when glob created midway (bug 45607)"); 1'
 	or die $@;
 }
 
@@ -610,7 +610,7 @@ foreach my $type (qw(integer number string)) {
     local $SIG{__WARN__} = sub { $warn = $_[0] };
     use warnings;
     my $str = "$glob";
-    is($warn, '', "RT #60954 anon glob stringification shouln't warn");
+    is($warn, '', "RT #60954 anon glob stringification shouldn't warn");
     is($str,  '', "RT #60954 anon glob stringification should be empty");
 }
 
diff --git a/t/op/incfilter.t b/t/op/incfilter.t
index 7b09966fb4..0b763e4d35 100644
--- a/t/op/incfilter.t
+++ b/t/op/incfilter.t
@@ -201,7 +201,7 @@ do [$fh, sub {$_ .= $_ . $_; return;}] or die;
 do \"pass\n(\n'Scalar references are treated as initial file contents'\n)\n"
 or die;
 
-open $fh, "<", \"ss('The file is concatentated');";
+open $fh, "<", \"ss('The file is concatenated');";
 
 do [\'pa', $fh] or die;
 
diff --git a/t/op/mydef.t b/t/op/mydef.t
index e034c78d3a..ca77c27032 100644
--- a/t/op/mydef.t
+++ b/t/op/mydef.t
@@ -71,7 +71,7 @@ $_ = "global";
     for ("implicit foo") { # implicit "my $_"
 	ok( $_ eq "implicit foo", 'for implicit my $_' );
 	/(.)/;
-	ok( $1 eq "i", '...m// in for implicity my $_' );
+	ok( $1 eq "i", '...m// in for implicit my $_' );
 	ok( our $_ eq 'global', '...our $_ inside for implicit my $_' );
     }
     ok( $_ eq 'local', '...my $_ restored outside for implicit my $_' );
diff --git a/t/op/numconvert.t b/t/op/numconvert.t
index d35386187f..73a35864cb 100644
--- a/t/op/numconvert.t
+++ b/t/op/numconvert.t
@@ -105,7 +105,7 @@ my $max_uv_p1 = "$max_uv"; $max_uv_p1+=0; $max_uv_p1++;
 
 # Also need to cope with %g notation for max_uv_p1 that actually gives an
 # integer less than max_uv because of correct rounding for the limited
-# precisision. This bites for 12 byte long doubles and 8 byte UVs
+# precision. This bites for 12 byte long doubles and 8 byte UVs
 
 my $temp = $max_uv_p1;
 my $max_uv_p1_as_iv;
diff --git a/t/op/override.t b/t/op/override.t
index e80cf6198e..413ba77e84 100644
--- a/t/op/override.t
+++ b/t/op/override.t
@@ -93,7 +93,7 @@ BEGIN { *Rgs::readpipe = sub ($) { ++$r . " $_[0]" }; }
     ::is( qx/cp/,	  "11 cp", 'qx' );
 }
 
-# Verify that the parsing of overriden keywords isn't messed up
+# Verify that the parsing of overridden keywords isn't messed up
 # by the indirect object notation
 {
     local $SIG{__WARN__} = sub {
diff --git a/t/op/pack.t b/t/op/pack.t
index 5775cafb53..025bb09f29 100644
--- a/t/op/pack.t
+++ b/t/op/pack.t
@@ -671,7 +671,7 @@ numbers ('d', -(2**34), -1, 0, 1, 2**34);
 numbers_with_total ('q', -1,
                     -9223372036854775808, -1, 0, 1,9223372036854775807);
 # This total is icky, but the true total is 2**65-1, and need a way to generate
-# the epxected checksum on any system including those where NVs can preserve
+# the expected checksum on any system including those where NVs can preserve
 # 65 bits. (long double is 128 bits on sparc, so they certainly can)
 # or where rounding is down not up on binary conversion (crays)
 numbers_with_total ('Q', sub {
diff --git a/t/op/pos.t b/t/op/pos.t
index 38fd03496b..56a8d28bb0 100644
--- a/t/op/pos.t
+++ b/t/op/pos.t
@@ -29,7 +29,7 @@ is(pos($x), 4);
 { local $x }
 is(pos($x), 4);
 
-# Explict test that triggers the utf8_mg_len_cache_update() code path in
+# Explicit test that triggers the utf8_mg_len_cache_update() code path in
 # Perl_sv_pos_b2u().
 
 $x = "\x{100}BC";
diff --git a/t/op/pow.t b/t/op/pow.t
index f6d752d868..c6a7ad6385 100644
--- a/t/op/pow.t
+++ b/t/op/pow.t
@@ -7,7 +7,7 @@ BEGIN {
     require './test.pl';
 }
 
-# This calcualtion ought to be within 0.001 of the right answer.
+# This calculation ought to be within 0.001 of the right answer.
 my $bits_in_uv = int (0.001 + log (~0+1) / log 2);
 
 # 3**30 < 2**48, don't trust things outside that range on a Cray
diff --git a/t/op/rand.t b/t/op/rand.t
index eb29ff94b0..0d602643a5 100644
--- a/t/op/rand.t
+++ b/t/op/rand.t
@@ -174,7 +174,7 @@ DIAG
     # to find out what's wrong with your rand. Or with this
     # algorithm. :-)
     #
-    # Calculating absoulute standard deviation for number of bits set
+    # Calculating absolute standard deviation for number of bits set
     # (eight bits per rep)
     $dev = abs ($bits - $reps * 4) / sqrt($reps * 2);
 
diff --git a/t/op/range.t b/t/op/range.t
index 81f7b0fcf3..a30e6f6aa7 100644
--- a/t/op/range.t
+++ b/t/op/range.t
@@ -341,7 +341,7 @@ foreach my $ii (~0, ~0+1, ~0+(~0>>4)) {
     ok($@, 'Lower bound rejected: ' . -$ii);
 }
 
-# double/tripple magic tests
+# double/triple magic tests
 sub TIESCALAR { bless { value => $_[1], orig => $_[1] } }
 sub STORE { $_[0]{store}++; $_[0]{value} = $_[1] }
 sub FETCH { $_[0]{fetch}++; $_[0]{value} }
diff --git a/t/op/ref.t b/t/op/ref.t
index 0a39f106c7..38c680088f 100644
--- a/t/op/ref.t
+++ b/t/op/ref.t
@@ -659,7 +659,7 @@ is( runperl(stderr => 1, prog => 'my $i;for $i (1) { for $i (2) { } }'), "");
 #    GV => blessed(AV) => RV => GV => blessed(SV)
 # all with a refcnt of 1, and hope that the second GV gets processed first
 # by do_clean_named_objs.  Then when the first GV is processed, it mustn't
-# find anything nastly left by the previous GV processing.
+# find anything nasty left by the previous GV processing.
 # The eval is stop things in the main body of the code holding a reference
 # to a GV, and the print at the end seems to bee necessary to ensure
 # the correct freeing order of *x and *y (no, I don't know why - DAPM).
diff --git a/t/op/stat.t b/t/op/stat.t
index 8d1b9f25c9..583191ca8e 100644
--- a/t/op/stat.t
+++ b/t/op/stat.t
@@ -499,7 +499,7 @@ SKIP: {
     ok(-d -r _ , "chained -x's on dirhandle"); 
     ok(-d DIR, "-d on a dirhandle works");
 
-    # And now for the ambigious bareword case
+    # And now for the ambiguous bareword case
     {
 	no warnings 'deprecated';
 	ok(open(DIR, "TEST"), 'Can open "TEST" dir')
@@ -532,7 +532,7 @@ SKIP: {
 	ok(-d _ , "The special file handle _ is set correctly"); 
         ok(-d -r *DIR{IO} , "chained -x's on *DIR{IO}");
 
-	# And now for the ambigious bareword case
+	# And now for the ambiguous bareword case
 	{
 	    no warnings 'deprecated';
 	    ok(open(DIR, "TEST"), 'Can open "TEST" dir')
diff --git a/t/op/taint.t b/t/op/taint.t
index ee8e2aae49..99a6a59a98 100644
--- a/t/op/taint.t
+++ b/t/op/taint.t
@@ -1358,7 +1358,7 @@ foreach my $ord (78, 163, 256) {
 # when the args were tainted. This only occured on the first use of
 # sprintf; after that, its TARG has taint magic attached, so setmagic
 # at the end works.  That's why there are multiple sprintf's below, rather
-# than just one wrapped in an inner loop. Also, any plantext betwerrn
+# than just one wrapped in an inner loop. Also, any plaintext between
 # fprmat entires would correctly cause tainting to get set. so test with
 # "%s%s" rather than eg "%s %s".
 
diff --git a/t/op/threads.t b/t/op/threads.t
index cf11ead1f8..240c00f7c6 100644
--- a/t/op/threads.t
+++ b/t/op/threads.t
@@ -166,7 +166,7 @@ curr_test(curr_test() + 2);
 
 
 # the seen_evals field of a regexp was getting zeroed on clone, so
-# within a thread it didn't  know that a regex object contrained a 'safe'
+# within a thread it didn't  know that a regex object contained a 'safe'
 # re_eval expression, so it later died with 'Eval-group not allowed' when
 # you tried to interpolate the object
 
diff --git a/t/op/tie.t b/t/op/tie.t
index 98f42799b9..a63c39cd6c 100644
--- a/t/op/tie.t
+++ b/t/op/tie.t
@@ -370,7 +370,7 @@ EXPECT
 # Test case from perlmonks by runrig
 # http://www.perlmonks.org/index.pl?node_id=273490
 # "Here is what I tried. I think its similar to what you've tried
-#  above. Its odd but convienient that after untie'ing you are left with
+#  above. Its odd but convenient that after untie'ing you are left with
 #  a variable that has the same value as was last returned from
 #  FETCH. (At least on my perl v5.6.1). So you don't need to pass a
 #  reference to the variable in order to set it after the untie (here it
diff --git a/t/op/utfhash.t b/t/op/utfhash.t
index a9af502fbf..ebb2934459 100644
--- a/t/op/utfhash.t
+++ b/t/op/utfhash.t
@@ -21,7 +21,7 @@ my %hashu = ( "\xff" => 0xff,
               "\x{1ff}" => 0x1ff,
             );
 
-# Check that we can find the 8-bit things by various litterals
+# Check that we can find the 8-bit things by various literals
 is($hash8{"\x{00ff}"},0xFF);
 is($hash8{"\x{007f}"},0x7F);
 is($hash8{"\xff"},0xFF);