Move Tie::File from ext/ to cpan/

39 files changed, 0 insertions, 8959 deletions

diff --git a/ext/Tie-File/lib/Tie/File.pm b/ext/Tie-File/lib/Tie/File.pm
deleted file mode 100644
index 9528ab1bfd..0000000000
--- a/ext/Tie-File/lib/Tie/File.pm
+++ /dev/null
@@ -1,2632 +0,0 @@
-
-package Tie::File;
-require 5.005;
-use Carp ':DEFAULT', 'confess';
-use POSIX 'SEEK_SET';
-use Fcntl 'O_CREAT', 'O_RDWR', 'LOCK_EX', 'LOCK_SH', 'O_WRONLY', 'O_RDONLY';
-sub O_ACCMODE () { O_RDONLY | O_RDWR | O_WRONLY }
-
-
-$VERSION = "0.97_02";
-my $DEFAULT_MEMORY_SIZE = 1<<21;    # 2 megabytes
-my $DEFAULT_AUTODEFER_THRESHHOLD = 3; # 3 records
-my $DEFAULT_AUTODEFER_FILELEN_THRESHHOLD = 65536; # 16 disk blocksful
-
-my %good_opt = map {$_ => 1, "-$_" => 1}
-                 qw(memory dw_size mode recsep discipline 
-                    autodefer autochomp autodefer_threshhold concurrent);
-
-sub TIEARRAY {
-  if (@_ % 2 != 0) {
-    croak "usage: tie \@array, $_[0], filename, [option => value]...";
-  }
-  my ($pack, $file, %opts) = @_;
-
-  # transform '-foo' keys into 'foo' keys
-  for my $key (keys %opts) {
-    unless ($good_opt{$key}) {
-      croak("$pack: Unrecognized option '$key'\n");
-    }
-    my $okey = $key;
-    if ($key =~ s/^-+//) {
-      $opts{$key} = delete $opts{$okey};
-    }
-  }
-
-  if ($opts{concurrent}) {
-    croak("$pack: concurrent access not supported yet\n");
-  }
-
-  unless (defined $opts{memory}) {
-    # default is the larger of the default cache size and the 
-    # deferred-write buffer size (if specified)
-    $opts{memory} = $DEFAULT_MEMORY_SIZE;
-    $opts{memory} = $opts{dw_size}
-      if defined $opts{dw_size} && $opts{dw_size} > $DEFAULT_MEMORY_SIZE;
-    # Dora Winifred Read
-  }
-  $opts{dw_size} = $opts{memory} unless defined $opts{dw_size};
-  if ($opts{dw_size} > $opts{memory}) {
-      croak("$pack: dw_size may not be larger than total memory allocation\n");
-  }
-  # are we in deferred-write mode?
-  $opts{defer} = 0 unless defined $opts{defer};
-  $opts{deferred} = {};         # no records are presently deferred
-  $opts{deferred_s} = 0;        # count of total bytes in ->{deferred}
-  $opts{deferred_max} = -1;     # empty
-
-  # What's a good way to arrange that this class can be overridden?
-  $opts{cache} = Tie::File::Cache->new($opts{memory});
-
-  # autodeferment is enabled by default
-  $opts{autodefer} = 1 unless defined $opts{autodefer};
-  $opts{autodeferring} = 0;     # but is not initially active
-  $opts{ad_history} = [];
-  $opts{autodefer_threshhold} = $DEFAULT_AUTODEFER_THRESHHOLD
-    unless defined $opts{autodefer_threshhold};
-  $opts{autodefer_filelen_threshhold} = $DEFAULT_AUTODEFER_FILELEN_THRESHHOLD
-    unless defined $opts{autodefer_filelen_threshhold};
-
-  $opts{offsets} = [0];
-  $opts{filename} = $file;
-  unless (defined $opts{recsep}) { 
-    $opts{recsep} = _default_recsep();
-  }
-  $opts{recseplen} = length($opts{recsep});
-  if ($opts{recseplen} == 0) {
-    croak "Empty record separator not supported by $pack";
-  }
-
-  $opts{autochomp} = 1 unless defined $opts{autochomp};
-
-  $opts{mode} = O_CREAT|O_RDWR unless defined $opts{mode};
-  $opts{rdonly} = (($opts{mode} & O_ACCMODE) == O_RDONLY);
-  $opts{sawlastrec} = undef;
-
-  my $fh;
-
-  if (UNIVERSAL::isa($file, 'GLOB')) {
-    # We use 1 here on the theory that some systems 
-    # may not indicate failure if we use 0.
-    # MSWin32 does not indicate failure with 0, but I don't know if
-    # it will indicate failure with 1 or not.
-    unless (seek $file, 1, SEEK_SET) {
-      croak "$pack: your filehandle does not appear to be seekable";
-    }
-    seek $file, 0, SEEK_SET;    # put it back
-    $fh = $file;                # setting binmode is the user's problem
-  } elsif (ref $file) {
-    croak "usage: tie \@array, $pack, filename, [option => value]...";
-  } else {
-    # $fh = \do { local *FH };  # XXX this is buggy
-    if ($] < 5.006) {
-	# perl 5.005 and earlier don't autovivify filehandles
-	require Symbol;
-	$fh = Symbol::gensym();
-    }
-    sysopen $fh, $file, $opts{mode}, 0666 or return;
-    binmode $fh;
-    ++$opts{ourfh};
-  }
-  { my $ofh = select $fh; $| = 1; select $ofh } # autoflush on write
-  if (defined $opts{discipline} && $] >= 5.006) {
-    # This avoids a compile-time warning under 5.005
-    eval 'binmode($fh, $opts{discipline})';
-    croak $@ if $@ =~ /unknown discipline/i;
-    die if $@;
-  }
-  $opts{fh} = $fh;
-
-  bless \%opts => $pack;
-}
-
-sub FETCH {
-  my ($self, $n) = @_;
-  my $rec;
-
-  # check the defer buffer
-  $rec = $self->{deferred}{$n} if exists $self->{deferred}{$n};
-  $rec = $self->_fetch($n) unless defined $rec;
-
-  # inlined _chomp1
-  substr($rec, - $self->{recseplen}) = ""
-    if defined $rec && $self->{autochomp};
-  $rec;
-}
-
-# Chomp many records in-place; return nothing useful
-sub _chomp {
-  my $self = shift;
-  return unless $self->{autochomp};
-  if ($self->{autochomp}) {
-    for (@_) {
-      next unless defined;
-      substr($_, - $self->{recseplen}) = "";
-    }
-  }
-}
-
-# Chomp one record in-place; return modified record
-sub _chomp1 {
-  my ($self, $rec) = @_;
-  return $rec unless $self->{autochomp};
-  return unless defined $rec;
-  substr($rec, - $self->{recseplen}) = "";
-  $rec;
-}
-
-sub _fetch {
-  my ($self, $n) = @_;
-
-  # check the record cache
-  { my $cached = $self->{cache}->lookup($n);
-    return $cached if defined $cached;
-  }
-
-  if ($#{$self->{offsets}} < $n) {
-    return if $self->{eof};  # request for record beyond end of file
-    my $o = $self->_fill_offsets_to($n);
-    # If it's still undefined, there is no such record, so return 'undef'
-    return unless defined $o;
-  }
-
-  my $fh = $self->{FH};
-  $self->_seek($n);             # we can do this now that offsets is populated
-  my $rec = $self->_read_record;
-
-# If we happen to have just read the first record, check to see if
-# the length of the record matches what 'tell' says.  If not, Tie::File
-# won't work, and should drop dead.
-#
-#  if ($n == 0 && defined($rec) && tell($self->{fh}) != length($rec)) {
-#    if (defined $self->{discipline}) {
-#      croak "I/O discipline $self->{discipline} not supported";
-#    } else {
-#      croak "File encoding not supported";
-#    }
-#  }
-
-  $self->{cache}->insert($n, $rec) if defined $rec && not $self->{flushing};
-  $rec;
-}
-
-sub STORE {
-  my ($self, $n, $rec) = @_;
-  die "STORE called from _check_integrity!" if $DIAGNOSTIC;
-
-  $self->_fixrecs($rec);
-
-  if ($self->{autodefer}) {
-    $self->_annotate_ad_history($n);
-  }
-
-  return $self->_store_deferred($n, $rec) if $self->_is_deferring;
-
-
-  # We need this to decide whether the new record will fit
-  # It incidentally populates the offsets table 
-  # Note we have to do this before we alter the cache
-  # 20020324 Wait, but this DOES alter the cache.  TODO BUG?
-  my $oldrec = $self->_fetch($n);
-
-  if (not defined $oldrec) {
-    # We're storing a record beyond the end of the file
-    $self->_extend_file_to($n+1);
-    $oldrec = $self->{recsep};
-  }
-#  return if $oldrec eq $rec;    # don't bother
-  my $len_diff = length($rec) - length($oldrec);
-
-  # length($oldrec) here is not consistent with text mode  TODO XXX BUG
-  $self->_mtwrite($rec, $self->{offsets}[$n], length($oldrec));
-  $self->_oadjust([$n, 1, $rec]);
-  $self->{cache}->update($n, $rec);
-}
-
-sub _store_deferred {
-  my ($self, $n, $rec) = @_;
-  $self->{cache}->remove($n);
-  my $old_deferred = $self->{deferred}{$n};
-
-  if (defined $self->{deferred_max} && $n > $self->{deferred_max}) {
-    $self->{deferred_max} = $n;
-  }
-  $self->{deferred}{$n} = $rec;
-
-  my $len_diff = length($rec);
-  $len_diff -= length($old_deferred) if defined $old_deferred;
-  $self->{deferred_s} += $len_diff;
-  $self->{cache}->adj_limit(-$len_diff);
-  if ($self->{deferred_s} > $self->{dw_size}) {
-    $self->_flush;
-  } elsif ($self->_cache_too_full) {
-    $self->_cache_flush;
-  }
-}
-
-# Remove a single record from the deferred-write buffer without writing it
-# The record need not be present
-sub _delete_deferred {
-  my ($self, $n) = @_;
-  my $rec = delete $self->{deferred}{$n};
-  return unless defined $rec;
-
-  if (defined $self->{deferred_max} 
-      && $n == $self->{deferred_max}) {
-    undef $self->{deferred_max};
-  }
-
-  $self->{deferred_s} -= length $rec;
-  $self->{cache}->adj_limit(length $rec);
-}
-
-sub FETCHSIZE {
-  my $self = shift;
-  my $n = $self->{eof} ? $#{$self->{offsets}} : $self->_fill_offsets;
-
-  my $top_deferred = $self->_defer_max;
-  $n = $top_deferred+1 if defined $top_deferred && $n < $top_deferred+1;
-  $n;
-}
-
-sub STORESIZE {
-  my ($self, $len) = @_;
-
-  if ($self->{autodefer}) {
-    $self->_annotate_ad_history('STORESIZE');
-  }
-
-  my $olen = $self->FETCHSIZE;
-  return if $len == $olen;      # Woo-hoo!
-
-  # file gets longer
-  if ($len > $olen) {
-    if ($self->_is_deferring) {
-      for ($olen .. $len-1) {
-        $self->_store_deferred($_, $self->{recsep});
-      }
-    } else {
-      $self->_extend_file_to($len);
-    }
-    return;
-  }
-
-  # file gets shorter
-  if ($self->_is_deferring) {
-    # TODO maybe replace this with map-plus-assignment?
-    for (grep $_ >= $len, keys %{$self->{deferred}}) {
-      $self->_delete_deferred($_);
-    }
-    $self->{deferred_max} = $len-1;
-  }
-
-  $self->_seek($len);
-  $self->_chop_file;
-  $#{$self->{offsets}} = $len;
-#  $self->{offsets}[0] = 0;      # in case we just chopped this
-
-  $self->{cache}->remove(grep $_ >= $len, $self->{cache}->ckeys);
-}
-
-### OPTIMIZE ME
-### It should not be necessary to do FETCHSIZE
-### Just seek to the end of the file.
-sub PUSH {
-  my $self = shift;
-  $self->SPLICE($self->FETCHSIZE, scalar(@_), @_);
-
-  # No need to return:
-  #  $self->FETCHSIZE;  # because av.c takes care of this for me
-}
-
-sub POP {
-  my $self = shift;
-  my $size = $self->FETCHSIZE;
-  return if $size == 0;
-#  print STDERR "# POPPITY POP POP POP\n";
-  scalar $self->SPLICE($size-1, 1);
-}
-
-sub SHIFT {
-  my $self = shift;
-  scalar $self->SPLICE(0, 1);
-}
-
-sub UNSHIFT {
-  my $self = shift;
-  $self->SPLICE(0, 0, @_);
-  # $self->FETCHSIZE; # av.c takes care of this for me
-}
-
-sub CLEAR {
-  my $self = shift;
-
-  if ($self->{autodefer}) {
-    $self->_annotate_ad_history('CLEAR');
-  }
-
-  $self->_seekb(0);
-  $self->_chop_file;
-    $self->{cache}->set_limit($self->{memory});
-    $self->{cache}->empty;
-  @{$self->{offsets}} = (0);
-  %{$self->{deferred}}= ();
-    $self->{deferred_s} = 0;
-    $self->{deferred_max} = -1;
-}
-
-sub EXTEND {
-  my ($self, $n) = @_;
-
-  # No need to pre-extend anything in this case
-  return if $self->_is_deferring;
-
-  $self->_fill_offsets_to($n);
-  $self->_extend_file_to($n);
-}
-
-sub DELETE {
-  my ($self, $n) = @_;
-
-  if ($self->{autodefer}) {
-    $self->_annotate_ad_history('DELETE');
-  }
-
-  my $lastrec = $self->FETCHSIZE-1;
-  my $rec = $self->FETCH($n);
-  $self->_delete_deferred($n) if $self->_is_deferring;
-  if ($n == $lastrec) {
-    $self->_seek($n);
-    $self->_chop_file;
-    $#{$self->{offsets}}--;
-    $self->{cache}->remove($n);
-    # perhaps in this case I should also remove trailing null records?
-    # 20020316
-    # Note that delete @a[-3..-1] deletes the records in the wrong order,
-    # so we only chop the very last one out of the file.  We could repair this
-    # by tracking deleted records inside the object.
-  } elsif ($n < $lastrec) {
-    $self->STORE($n, "");
-  }
-  $rec;
-}
-
-sub EXISTS {
-  my ($self, $n) = @_;
-  return 1 if exists $self->{deferred}{$n};
-  $n < $self->FETCHSIZE;
-}
-
-sub SPLICE {
-  my $self = shift;
-
-  if ($self->{autodefer}) {
-    $self->_annotate_ad_history('SPLICE');
-  }
-
-  $self->_flush if $self->_is_deferring; # move this up?
-  if (wantarray) {
-    $self->_chomp(my @a = $self->_splice(@_));
-    @a;
-  } else {
-    $self->_chomp1(scalar $self->_splice(@_));
-  }
-}
-
-sub DESTROY {
-  my $self = shift;
-  $self->flush if $self->_is_deferring;
-  $self->{cache}->delink if defined $self->{cache}; # break circular link
-  if ($self->{fh} and $self->{ourfh}) {
-      delete $self->{ourfh};
-      close delete $self->{fh};
-  }
-}
-
-sub _splice {
-  my ($self, $pos, $nrecs, @data) = @_;
-  my @result;
-
-  $pos = 0 unless defined $pos;
-
-  # Deal with negative and other out-of-range positions
-  # Also set default for $nrecs 
-  {
-    my $oldsize = $self->FETCHSIZE;
-    $nrecs = $oldsize unless defined $nrecs;
-    my $oldpos = $pos;
-
-    if ($pos < 0) {
-      $pos += $oldsize;
-      if ($pos < 0) {
-        croak "Modification of non-creatable array value attempted, subscript $oldpos";
-      }
-    }
-
-    if ($pos > $oldsize) {
-      return unless @data;
-      $pos = $oldsize;          # This is what perl does for normal arrays
-    }
-
-    # The manual is very unclear here
-    if ($nrecs < 0) {
-      $nrecs = $oldsize - $pos + $nrecs;
-      $nrecs = 0 if $nrecs < 0;
-    }
-
-    # nrecs is too big---it really means "until the end"
-    # 20030507
-    if ($nrecs + $pos > $oldsize) {
-      $nrecs = $oldsize - $pos;
-    }
-  }
-
-  $self->_fixrecs(@data);
-  my $data = join '', @data;
-  my $datalen = length $data;
-  my $oldlen = 0;
-
-  # compute length of data being removed
-  for ($pos .. $pos+$nrecs-1) {
-    last unless defined $self->_fill_offsets_to($_);
-    my $rec = $self->_fetch($_);
-    last unless defined $rec;
-    push @result, $rec;
-
-    # Why don't we just use length($rec) here?
-    # Because that record might have come from the cache.  _splice
-    # might have been called to flush out the deferred-write records,
-    # and in this case length($rec) is the length of the record to be
-    # *written*, not the length of the actual record in the file.  But
-    # the offsets are still true. 20020322
-    $oldlen += $self->{offsets}[$_+1] - $self->{offsets}[$_]
-      if defined $self->{offsets}[$_+1];
-  }
-  $self->_fill_offsets_to($pos+$nrecs);
-
-  # Modify the file
-  $self->_mtwrite($data, $self->{offsets}[$pos], $oldlen);
-  # Adjust the offsets table
-  $self->_oadjust([$pos, $nrecs, @data]);
-
-  { # Take this read cache stuff out into a separate function
-    # You made a half-attempt to put it into _oadjust.  
-    # Finish something like that up eventually.
-    # STORE also needs to do something similarish
-
-    # update the read cache, part 1
-    # modified records
-    for ($pos .. $pos+$nrecs-1) {
-      my $new = $data[$_-$pos];
-      if (defined $new) {
-        $self->{cache}->update($_, $new);
-      } else {
-        $self->{cache}->remove($_);
-      }
-    }
-    
-    # update the read cache, part 2
-    # moved records - records past the site of the change
-    # need to be renumbered
-    # Maybe merge this with the previous block?
-    {
-      my @oldkeys = grep $_ >= $pos + $nrecs, $self->{cache}->ckeys;
-      my @newkeys = map $_-$nrecs+@data, @oldkeys;
-      $self->{cache}->rekey(\@oldkeys, \@newkeys);
-    }
-
-    # Now there might be too much data in the cache, if we spliced out
-    # some short records and spliced in some long ones.  If so, flush
-    # the cache.
-    $self->_cache_flush;
-  }
-
-  # Yes, the return value of 'splice' *is* actually this complicated
-  wantarray ? @result : @result ? $result[-1] : undef;
-}
-
-
-# write data into the file
-# $data is the data to be written.
-# it should be written at position $pos, and should overwrite
-# exactly $len of the following bytes.  
-# Note that if length($data) > $len, the subsequent bytes will have to 
-# be moved up, and if length($data) < $len, they will have to
-# be moved down
-sub _twrite {
-  my ($self, $data, $pos, $len) = @_;
-
-  unless (defined $pos) {
-    die "\$pos was undefined in _twrite";
-  }
-
-  my $len_diff = length($data) - $len;
-
-  if ($len_diff == 0) {          # Woo-hoo!
-    my $fh = $self->{fh};
-    $self->_seekb($pos);
-    $self->_write_record($data);
-    return;                     # well, that was easy.
-  }
-
-  # the two records are of different lengths
-  # our strategy here: rewrite the tail of the file,
-  # reading ahead one buffer at a time
-  # $bufsize is required to be at least as large as the data we're overwriting
-  my $bufsize = _bufsize($len_diff);
-  my ($writepos, $readpos) = ($pos, $pos+$len);
-  my $next_block;
-  my $more_data;
-
-  # Seems like there ought to be a way to avoid the repeated code
-  # and the special case here.  The read(1) is also a little weird.
-  # Think about this.
-  do {
-    $self->_seekb($readpos);
-    my $br = read $self->{fh}, $next_block, $bufsize;
-    $more_data = read $self->{fh}, my($dummy), 1;
-    $self->_seekb($writepos);
-    $self->_write_record($data);
-    $readpos += $br;
-    $writepos += length $data;
-    $data = $next_block;
-  } while $more_data;
-  $self->_seekb($writepos);
-  $self->_write_record($next_block);
-
-  # There might be leftover data at the end of the file
-  $self->_chop_file if $len_diff < 0;
-}
-
-# _iwrite(D, S, E)
-# Insert text D at position S.
-# Let C = E-S-|D|.  If C < 0; die.  
-# Data in [S,S+C) is copied to [S+D,S+D+C) = [S+D,E).
-# Data in [S+C = E-D, E) is returned.  Data in [E, oo) is untouched.
-#
-# In a later version, don't read the entire intervening area into
-# memory at once; do the copying block by block.
-sub _iwrite {
-  my $self = shift;
-  my ($D, $s, $e) = @_;
-  my $d = length $D;
-  my $c = $e-$s-$d;
-  local *FH = $self->{fh};
-  confess "Not enough space to insert $d bytes between $s and $e"
-    if $c < 0;
-  confess "[$s,$e) is an invalid insertion range" if $e < $s;
-
-  $self->_seekb($s);
-  read FH, my $buf, $e-$s;
-
-  $D .= substr($buf, 0, $c, "");
-
-  $self->_seekb($s);
-  $self->_write_record($D);
-
-  return $buf;
-}
-
-# Like _twrite, but the data-pos-len triple may be repeated; you may
-# write several chunks.  All the writing will be done in
-# one pass.   Chunks SHALL be in ascending order and SHALL NOT overlap.
-sub _mtwrite {
-  my $self = shift;
-  my $unwritten = "";
-  my $delta = 0;
-
-  @_ % 3 == 0 
-    or die "Arguments to _mtwrite did not come in groups of three";
-
-  while (@_) {
-    my ($data, $pos, $len) = splice @_, 0, 3;
-    my $end = $pos + $len;  # The OLD end of the segment to be replaced
-    $data = $unwritten . $data;
-    $delta -= length($unwritten);
-    $unwritten  = "";
-    $pos += $delta;             # This is where the data goes now
-    my $dlen = length $data;
-    $self->_seekb($pos);
-    if ($len >= $dlen) {        # the data will fit
-      $self->_write_record($data);
-      $delta += ($dlen - $len); # everything following moves down by this much
-      $data = ""; # All the data in the buffer has been written
-    } else {                    # won't fit
-      my $writable = substr($data, 0, $len - $delta, "");
-      $self->_write_record($writable);
-      $delta += ($dlen - $len); # everything following moves down by this much
-    } 
-
-    # At this point we've written some but maybe not all of the data.
-    # There might be a gap to close up, or $data might still contain a
-    # bunch of unwritten data that didn't fit.
-    my $ndlen = length $data;
-    if ($delta == 0) {
-      $self->_write_record($data);
-    } elsif ($delta < 0) {
-      # upcopy (close up gap)
-      if (@_) {
-        $self->_upcopy($end, $end + $delta, $_[1] - $end);  
-      } else {
-        $self->_upcopy($end, $end + $delta);  
-      }
-    } else {
-      # downcopy (insert data that didn't fit; replace this data in memory
-      # with _later_ data that doesn't fit)
-      if (@_) {
-        $unwritten = $self->_downcopy($data, $end, $_[1] - $end);
-      } else {
-        # Make the file longer to accommodate the last segment that doesn'
-        $unwritten = $self->_downcopy($data, $end);
-      }
-    }
-  }
-}
-
-# Copy block of data of length $len from position $spos to position $dpos
-# $dpos must be <= $spos
-#
-# If $len is undefined, go all the way to the end of the file
-# and then truncate it ($spos - $dpos bytes will be removed)
-sub _upcopy {
-  my $blocksize = 8192;
-  my ($self, $spos, $dpos, $len) = @_;
-  if ($dpos > $spos) {
-    die "source ($spos) was upstream of destination ($dpos) in _upcopy";
-  } elsif ($dpos == $spos) {
-    return;
-  }
-  
-  while (! defined ($len) || $len > 0) {
-    my $readsize = ! defined($len) ? $blocksize
-               : $len > $blocksize ? $blocksize
-               : $len;
-      
-    my $fh = $self->{fh};
-    $self->_seekb($spos);
-    my $bytes_read = read $fh, my($data), $readsize;
-    $self->_seekb($dpos);
-    if ($data eq "") { 
-      $self->_chop_file;
-      last;
-    }
-    $self->_write_record($data);
-    $spos += $bytes_read;
-    $dpos += $bytes_read;
-    $len -= $bytes_read if defined $len;
-  }
-}
-
-# Write $data into a block of length $len at position $pos,
-# moving everything in the block forwards to make room.
-# Instead of writing the last length($data) bytes from the block
-# (because there isn't room for them any longer) return them.
-#
-# Undefined $len means 'until the end of the file'
-sub _downcopy {
-  my $blocksize = 8192;
-  my ($self, $data, $pos, $len) = @_;
-  my $fh = $self->{fh};
-
-  while (! defined $len || $len > 0) {
-    my $readsize = ! defined($len) ? $blocksize 
-      : $len > $blocksize? $blocksize : $len;
-    $self->_seekb($pos);
-    read $fh, my($old), $readsize;
-    my $last_read_was_short = length($old) < $readsize;
-    $data .= $old;
-    my $writable;
-    if ($last_read_was_short) {
-      # If last read was short, then $data now contains the entire rest
-      # of the file, so there's no need to write only one block of it
-      $writable = $data;
-      $data = "";
-    } else {
-      $writable = substr($data, 0, $readsize, "");
-    }
-    last if $writable eq "";
-    $self->_seekb($pos);
-    $self->_write_record($writable);
-    last if $last_read_was_short && $data eq "";
-    $len -= $readsize if defined $len;
-    $pos += $readsize;
-  }
-  return $data;
-}
-
-# Adjust the object data structures following an '_mtwrite'
-# Arguments are
-#  [$pos, $nrecs, @length]  items
-# indicating that $nrecs records were removed at $recpos (a record offset)
-# and replaced with records of length @length...
-# Arguments guarantee that $recpos is strictly increasing.
-# No return value
-sub _oadjust {
-  my $self = shift;
-  my $delta = 0;
-  my $delta_recs = 0;
-  my $prev_end = -1;
-  my %newkeys;
-
-  for (@_) {
-    my ($pos, $nrecs, @data) = @$_;
-    $pos += $delta_recs;
-
-    # Adjust the offsets of the records after the previous batch up
-    # to the first new one of this batch
-    for my $i ($prev_end+2 .. $pos - 1) {
-      $self->{offsets}[$i] += $delta;
-      $newkey{$i} = $i + $delta_recs;
-    }
-
-    $prev_end = $pos + @data - 1; # last record moved on this pass 
-
-    # Remove the offsets for the removed records;
-    # replace with the offsets for the inserted records
-    my @newoff = ($self->{offsets}[$pos] + $delta);
-    for my $i (0 .. $#data) {
-      my $newlen = length $data[$i];
-      push @newoff, $newoff[$i] + $newlen;
-      $delta += $newlen;
-    }
-
-    for my $i ($pos .. $pos+$nrecs-1) {
-      last if $i+1 > $#{$self->{offsets}};
-      my $oldlen = $self->{offsets}[$i+1] - $self->{offsets}[$i];
-      $delta -= $oldlen;
-    }
-
-#    # also this data has changed, so update it in the cache
-#    for (0 .. $#data) {
-#      $self->{cache}->update($pos + $_, $data[$_]);
-#    }
-#    if ($delta_recs) {
-#      my @oldkeys = grep $_ >= $pos + @data, $self->{cache}->ckeys;
-#      my @newkeys = map $_ + $delta_recs, @oldkeys;
-#      $self->{cache}->rekey(\@oldkeys, \@newkeys);
-#    }
-
-    # replace old offsets with new
-    splice @{$self->{offsets}}, $pos, $nrecs+1, @newoff;
-    # What if we just spliced out the end of the offsets table?
-    # shouldn't we clear $self->{eof}?   Test for this XXX BUG TODO
-
-    $delta_recs += @data - $nrecs; # net change in total number of records
-  }
-
-  # The trailing records at the very end of the file
-  if ($delta) {
-    for my $i ($prev_end+2 .. $#{$self->{offsets}}) {
-      $self->{offsets}[$i] += $delta;
-    }
-  }
-
-  # If we scrubbed out all known offsets, regenerate the trivial table
-  # that knows that the file does indeed start at 0.
-  $self->{offsets}[0] = 0 unless @{$self->{offsets}};
-  # If the file got longer, the offsets table is no longer complete
-  # $self->{eof} = 0 if $delta_recs > 0;
-
-  # Now there might be too much data in the cache, if we spliced out
-  # some short records and spliced in some long ones.  If so, flush
-  # the cache.
-  $self->_cache_flush;
-}
-
-# If a record does not already end with the appropriate terminator
-# string, append one.
-sub _fixrecs {
-  my $self = shift;
-  for (@_) {
-    $_ = "" unless defined $_;
-    $_ .= $self->{recsep}
-      unless substr($_, - $self->{recseplen}) eq $self->{recsep};
-  }
-}
-
-
-################################################################
-#
-# Basic read, write, and seek
-#
-
-# seek to the beginning of record #$n
-# Assumes that the offsets table is already correctly populated
-#
-# Note that $n=-1 has a special meaning here: It means the start of
-# the last known record; this may or may not be the very last record
-# in the file, depending on whether the offsets table is fully populated.
-#
-sub _seek {
-  my ($self, $n) = @_;
-  my $o = $self->{offsets}[$n];
-  defined($o)
-    or confess("logic error: undefined offset for record $n");
-  seek $self->{fh}, $o, SEEK_SET
-    or confess "Couldn't seek filehandle: $!";  # "Should never happen."
-}
-
-# seek to byte $b in the file
-sub _seekb {
-  my ($self, $b) = @_;
-  seek $self->{fh}, $b, SEEK_SET
-    or die "Couldn't seek filehandle: $!";  # "Should never happen."
-}
-
-# populate the offsets table up to the beginning of record $n
-# return the offset of record $n
-sub _fill_offsets_to {
-  my ($self, $n) = @_;
-
-  return $self->{offsets}[$n] if $self->{eof};
-
-  my $fh = $self->{fh};
-  local *OFF = $self->{offsets};
-  my $rec;
-
-  until ($#OFF >= $n) {
-    $self->_seek(-1);           # tricky -- see comment at _seek
-    $rec = $self->_read_record;
-    if (defined $rec) {
-      push @OFF, int(tell $fh);  # Tels says that int() saves memory here
-    } else {
-      $self->{eof} = 1;
-      return;                   # It turns out there is no such record
-    }
-  }
-
-  # we have now read all the records up to record n-1,
-  # so we can return the offset of record n
-  $OFF[$n];
-}
-
-sub _fill_offsets {
-  my ($self) = @_;
-
-  my $fh = $self->{fh};
-  local *OFF = $self->{offsets};
-  
-  $self->_seek(-1);           # tricky -- see comment at _seek
-
-  # Tels says that inlining read_record() would make this loop
-  # five times faster. 20030508
-  while ( defined $self->_read_record()) {
-    # int() saves us memory here
-    push @OFF, int(tell $fh);
-  }
-
-  $self->{eof} = 1;
-  $#OFF;
-}
-
-# assumes that $rec is already suitably terminated
-sub _write_record {
-  my ($self, $rec) = @_;
-  my $fh = $self->{fh};
-  local $\ = "";
-  print $fh $rec
-    or die "Couldn't write record: $!";  # "Should never happen."
-#  $self->{_written} += length($rec);
-}
-
-sub _read_record {
-  my $self = shift;
-  my $rec;
-  { local $/ = $self->{recsep};
-    my $fh = $self->{fh};
-    $rec = <$fh>;
-  }
-  return unless defined $rec;
-  if (substr($rec, -$self->{recseplen}) ne $self->{recsep}) {
-    # improperly terminated final record --- quietly fix it.
-#    my $ac = substr($rec, -$self->{recseplen});
-#    $ac =~ s/\n/\\n/g;
-    $self->{sawlastrec} = 1;
-    unless ($self->{rdonly}) {
-      local $\ = "";
-      my $fh = $self->{fh};
-      print $fh $self->{recsep};
-    }
-    $rec .= $self->{recsep};
-  }
-#  $self->{_read} += length($rec) if defined $rec;
-  $rec;
-}
-
-sub _rw_stats {
-  my $self = shift;
-  @{$self}{'_read', '_written'};
-}
-
-################################################################
-#
-# Read cache management
-
-sub _cache_flush {
-  my ($self) = @_;
-  $self->{cache}->reduce_size_to($self->{memory} - $self->{deferred_s});
-}
-
-sub _cache_too_full {
-  my $self = shift;
-  $self->{cache}->bytes + $self->{deferred_s} >= $self->{memory};
-}
-
-################################################################
-#
-# File custodial services
-#
-
-
-# We have read to the end of the file and have the offsets table
-# entirely populated.  Now we need to write a new record beyond
-# the end of the file.  We prepare for this by writing
-# empty records into the file up to the position we want
-#
-# assumes that the offsets table already contains the offset of record $n,
-# if it exists, and extends to the end of the file if not.
-sub _extend_file_to {
-  my ($self, $n) = @_;
-  $self->_seek(-1);             # position after the end of the last record
-  my $pos = $self->{offsets}[-1];
-
-  # the offsets table has one entry more than the total number of records
-  my $extras = $n - $#{$self->{offsets}};
-
-  # Todo : just use $self->{recsep} x $extras here?
-  while ($extras-- > 0) {
-    $self->_write_record($self->{recsep});
-    push @{$self->{offsets}}, int(tell $self->{fh});
-  }
-}
-
-# Truncate the file at the current position
-sub _chop_file {
-  my $self = shift;
-  truncate $self->{fh}, tell($self->{fh});
-}
-
-
-# compute the size of a buffer suitable for moving
-# all the data in a file forward $n bytes
-# ($n may be negative)
-# The result should be at least $n.
-sub _bufsize {
-  my $n = shift;
-  return 8192 if $n <= 0;
-  my $b = $n & ~8191;
-  $b += 8192 if $n & 8191;
-  $b;
-}
-
-################################################################
-#
-# Miscellaneous public methods
-#
-
-# Lock the file
-sub flock {
-  my ($self, $op) = @_;
-  unless (@_ <= 3) {
-    my $pack = ref $self;
-    croak "Usage: $pack\->flock([OPERATION])";
-  }
-  my $fh = $self->{fh};
-  $op = LOCK_EX unless defined $op;
-  my $locked = flock $fh, $op;
-  
-  if ($locked && ($op & (LOCK_EX | LOCK_SH))) {
-    # If you're locking the file, then presumably it's because
-    # there might have been a write access by another process.
-    # In that case, the read cache contents and the offsets table
-    # might be invalid, so discard them.  20030508
-    $self->{offsets} = [0];
-    $self->{cache}->empty;
-  }
-
-  $locked;
-}
-
-# Get/set autochomp option
-sub autochomp {
-  my $self = shift;
-  if (@_) {
-    my $old = $self->{autochomp};
-    $self->{autochomp} = shift;
-    $old;
-  } else {
-    $self->{autochomp};
-  }
-}
-
-# Get offset table entries; returns offset of nth record
-sub offset {
-  my ($self, $n) = @_;
-
-  if ($#{$self->{offsets}} < $n) {
-    return if $self->{eof};     # request for record beyond the end of file
-    my $o = $self->_fill_offsets_to($n);
-    # If it's still undefined, there is no such record, so return 'undef'
-    return unless defined $o;
-   }
- 
-  $self->{offsets}[$n];
-}
-
-sub discard_offsets {
-  my $self = shift;
-  $self->{offsets} = [0];
-}
-
-################################################################
-#
-# Matters related to deferred writing
-#
-
-# Defer writes
-sub defer {
-  my $self = shift;
-  $self->_stop_autodeferring;
-  @{$self->{ad_history}} = ();
-  $self->{defer} = 1;
-}
-
-# Flush deferred writes
-#
-# This could be better optimized to write the file in one pass, instead
-# of one pass per block of records.  But that will require modifications
-# to _twrite, so I should have a good _twrite test suite first.
-sub flush {
-  my $self = shift;
-
-  $self->_flush;
-  $self->{defer} = 0;
-}
-
-sub _old_flush {
-  my $self = shift;
-  my @writable = sort {$a<=>$b} (keys %{$self->{deferred}});
-
-  while (@writable) {
-    # gather all consecutive records from the front of @writable
-    my $first_rec = shift @writable;
-    my $last_rec = $first_rec+1;
-    ++$last_rec, shift @writable while @writable && $last_rec == $writable[0];
-    --$last_rec;
-    $self->_fill_offsets_to($last_rec);
-    $self->_extend_file_to($last_rec);
-    $self->_splice($first_rec, $last_rec-$first_rec+1, 
-                   @{$self->{deferred}}{$first_rec .. $last_rec});
-  }
-
-  $self->_discard;               # clear out defered-write-cache
-}
-
-sub _flush {
-  my $self = shift;
-  my @writable = sort {$a<=>$b} (keys %{$self->{deferred}});
-  my @args;
-  my @adjust;
-
-  while (@writable) {
-    # gather all consecutive records from the front of @writable
-    my $first_rec = shift @writable;
-    my $last_rec = $first_rec+1;
-    ++$last_rec, shift @writable while @writable && $last_rec == $writable[0];
-    --$last_rec;
-    my $end = $self->_fill_offsets_to($last_rec+1);
-    if (not defined $end) {
-      $self->_extend_file_to($last_rec);
-      $end = $self->{offsets}[$last_rec];
-    }
-    my ($start) = $self->{offsets}[$first_rec];
-    push @args,
-         join("", @{$self->{deferred}}{$first_rec .. $last_rec}), # data
-         $start,                                                  # position
-         $end-$start;                                             # length
-    push @adjust, [$first_rec, # starting at this position...
-                   $last_rec-$first_rec+1,  # this many records...
-                   # are replaced with these...
-                   @{$self->{deferred}}{$first_rec .. $last_rec},
-                  ];
-  }
-
-  $self->_mtwrite(@args);  # write multiple record groups
-  $self->_discard;               # clear out defered-write-cache
-  $self->_oadjust(@adjust);
-}
-
-# Discard deferred writes and disable future deferred writes
-sub discard {
-  my $self = shift;
-  $self->_discard;
-  $self->{defer} = 0;
-}
-
-# Discard deferred writes, but retain old deferred writing mode
-sub _discard {
-  my $self = shift;
-  %{$self->{deferred}} = ();
-  $self->{deferred_s}  = 0;
-  $self->{deferred_max}  = -1;
-  $self->{cache}->set_limit($self->{memory});
-}
-
-# Deferred writing is enabled, either explicitly ($self->{defer})
-# or automatically ($self->{autodeferring})
-sub _is_deferring {
-  my $self = shift;
-  $self->{defer} || $self->{autodeferring};
-}
-
-# The largest record number of any deferred record
-sub _defer_max {
-  my $self = shift;
-  return $self->{deferred_max} if defined $self->{deferred_max};
-  my $max = -1;
-  for my $key (keys %{$self->{deferred}}) {
-    $max = $key if $key > $max;
-  }
-  $self->{deferred_max} = $max;
-  $max;
-}
-
-################################################################
-#
-# Matters related to autodeferment
-#
-
-# Get/set autodefer option
-sub autodefer {
-  my $self = shift;
-  if (@_) {
-    my $old = $self->{autodefer};
-    $self->{autodefer} = shift;
-    if ($old) {
-      $self->_stop_autodeferring;
-      @{$self->{ad_history}} = ();
-    }
-    $old;
-  } else {
-    $self->{autodefer};
-  }
-}
-
-# The user is trying to store record #$n Record that in the history,
-# and then enable (or disable) autodeferment if that seems useful.
-# Note that it's OK for $n to be a non-number, as long as the function
-# is prepared to deal with that.  Nobody else looks at the ad_history.
-#
-# Now, what does the ad_history mean, and what is this function doing?
-# Essentially, the idea is to enable autodeferring when we see that the
-# user has made three consecutive STORE calls to three consecutive records.
-# ("Three" is actually ->{autodefer_threshhold}.)
-# A STORE call for record #$n inserts $n into the autodefer history,
-# and if the history contains three consecutive records, we enable 
-# autodeferment.  An ad_history of [X, Y] means that the most recent
-# STOREs were for records X, X+1, ..., Y, in that order.  
-#
-# Inserting a nonconsecutive number erases the history and starts over.
-#
-# Performing a special operation like SPLICE erases the history.
-#
-# There's one special case: CLEAR means that CLEAR was just called.
-# In this case, we prime the history with [-2, -1] so that if the next
-# write is for record 0, autodeferring goes on immediately.  This is for
-# the common special case of "@a = (...)".
-#
-sub _annotate_ad_history {
-  my ($self, $n) = @_;
-  return unless $self->{autodefer}; # feature is disabled
-  return if $self->{defer};     # already in explicit defer mode
-  return unless $self->{offsets}[-1] >= $self->{autodefer_filelen_threshhold};
-
-  local *H = $self->{ad_history};
-  if ($n eq 'CLEAR') {
-    @H = (-2, -1);              # prime the history with fake records
-    $self->_stop_autodeferring;
-  } elsif ($n =~ /^\d+$/) {
-    if (@H == 0) {
-      @H =  ($n, $n);
-    } else {                    # @H == 2
-      if ($H[1] == $n-1) {      # another consecutive record
-        $H[1]++;
-        if ($H[1] - $H[0] + 1 >= $self->{autodefer_threshhold}) {
-          $self->{autodeferring} = 1;
-        }
-      } else {                  # nonconsecutive- erase and start over
-        @H = ($n, $n);
-        $self->_stop_autodeferring;
-      }
-    }
-  } else {                      # SPLICE or STORESIZE or some such
-    @H = ();
-    $self->_stop_autodeferring;
-  }
-}
-
-# If autodeferring was enabled, cut it out and discard the history
-sub _stop_autodeferring {
-  my $self = shift;
-  if ($self->{autodeferring}) {
-    $self->_flush;
-  }
-  $self->{autodeferring} = 0;
-}
-
-################################################################
-
-
-# This is NOT a method.  It is here for two reasons:
-#  1. To factor a fairly complicated block out of the constructor
-#  2. To provide access for the test suite, which need to be sure
-#     files are being written properly.
-sub _default_recsep {
-  my $recsep = $/;
-  if ($^O eq 'MSWin32') {       # Dos too?
-    # Windows users expect files to be terminated with \r\n
-    # But $/ is set to \n instead
-    # Note that this also transforms \n\n into \r\n\r\n.
-    # That is a feature.
-    $recsep =~ s/\n/\r\n/g;
-  }
-  $recsep;
-}
-
-# Utility function for _check_integrity
-sub _ci_warn {
-  my $msg = shift;
-  $msg =~ s/\n/\\n/g;
-  $msg =~ s/\r/\\r/g;
-  print "# $msg\n";
-}
-
-# Given a file, make sure the cache is consistent with the
-# file contents and the internal data structures are consistent with
-# each other.  Returns true if everything checks out, false if not
-#
-# The $file argument is no longer used.  It is retained for compatibility
-# with the existing test suite.
-sub _check_integrity {
-  my ($self, $file, $warn) = @_;
-  my $rsl = $self->{recseplen};
-  my $rs  = $self->{recsep};
-  my $good = 1; 
-  local *_;                     # local $_ does not work here
-  local $DIAGNOSTIC = 1;
-
-  if (not defined $rs) {
-    _ci_warn("recsep is undef!");
-    $good = 0;
-  } elsif ($rs eq "") {
-    _ci_warn("recsep is empty!");
-    $good = 0;
-  } elsif ($rsl != length $rs) {
-    my $ln = length $rs;
-    _ci_warn("recsep <$rs> has length $ln, should be $rsl");
-    $good = 0;
-  }
-
-  if (not defined $self->{offsets}[0]) {
-    _ci_warn("offset 0 is missing!");
-    $good = 0;
-
-  } elsif ($self->{offsets}[0] != 0) {
-    _ci_warn("rec 0: offset <$self->{offsets}[0]> s/b 0!");
-    $good = 0;
-  }
-
-  my $cached = 0;
-  {
-    local *F = $self->{fh};
-    seek F, 0, SEEK_SET;
-    local $. = 0;
-    local $/ = $rs;
-
-    while (<F>) {
-      my $n = $. - 1;
-      my $cached = $self->{cache}->_produce($n);
-      my $offset = $self->{offsets}[$.];
-      my $ao = tell F;
-      if (defined $offset && $offset != $ao) {
-        _ci_warn("rec $n: offset <$offset> actual <$ao>");
-        $good = 0;
-      }
-      if (defined $cached && $_ ne $cached && ! $self->{deferred}{$n}) {
-        $good = 0;
-        _ci_warn("rec $n: cached <$cached> actual <$_>");
-      }
-      if (defined $cached && substr($cached, -$rsl) ne $rs) {
-        $good = 0;
-        _ci_warn("rec $n in the cache is missing the record separator");
-      }
-      if (! defined $offset && $self->{eof}) {
-        $good = 0;
-        _ci_warn("The offset table was marked complete, but it is missing element $.");
-      }
-    }
-    if (@{$self->{offsets}} > $.+1) {
-        $good = 0;
-        my $n = @{$self->{offsets}};
-        _ci_warn("The offset table has $n items, but the file has only $.");
-    }
-
-    my $deferring = $self->_is_deferring;
-    for my $n ($self->{cache}->ckeys) {
-      my $r = $self->{cache}->_produce($n);
-      $cached += length($r);
-      next if $n+1 <= $.;         # checked this already
-      _ci_warn("spurious caching of record $n");
-      $good = 0;
-    }
-    my $b = $self->{cache}->bytes;
-    if ($cached != $b) {
-      _ci_warn("cache size is $b, should be $cached");
-      $good = 0;
-    }
-  }
-
-  # That cache has its own set of tests
-  $good = 0 unless $self->{cache}->_check_integrity;
-
-  # Now let's check the deferbuffer
-  # Unless deferred writing is enabled, it should be empty
-  if (! $self->_is_deferring && %{$self->{deferred}}) {
-    _ci_warn("deferred writing disabled, but deferbuffer nonempty");
-    $good = 0;
-  }
-
-  # Any record in the deferbuffer should *not* be present in the readcache
-  my $deferred_s = 0;
-  while (my ($n, $r) = each %{$self->{deferred}}) {
-    $deferred_s += length($r);
-    if (defined $self->{cache}->_produce($n)) {
-      _ci_warn("record $n is in the deferbuffer *and* the readcache");
-      $good = 0;
-    }
-    if (substr($r, -$rsl) ne $rs) {
-      _ci_warn("rec $n in the deferbuffer is missing the record separator");
-      $good = 0;
-    }
-  }
-
-  # Total size of deferbuffer should match internal total
-  if ($deferred_s != $self->{deferred_s}) {
-    _ci_warn("buffer size is $self->{deferred_s}, should be $deferred_s");
-    $good = 0;
-  }
-
-  # Total size of deferbuffer should not exceed the specified limit
-  if ($deferred_s > $self->{dw_size}) {
-    _ci_warn("buffer size is $self->{deferred_s} which exceeds the limit of $self->{dw_size}");
-    $good = 0;
-  }
-
-  # Total size of cached data should not exceed the specified limit
-  if ($deferred_s + $cached > $self->{memory}) {
-    my $total = $deferred_s + $cached;
-    _ci_warn("total stored data size is $total which exceeds the limit of $self->{memory}");
-    $good = 0;
-  }
-
-  # Stuff related to autodeferment
-  if (!$self->{autodefer} && @{$self->{ad_history}}) {
-    _ci_warn("autodefer is disabled, but ad_history is nonempty");
-    $good = 0;
-  }
-  if ($self->{autodeferring} && $self->{defer}) {
-    _ci_warn("both autodeferring and explicit deferring are active");
-    $good = 0;
-  }
-  if (@{$self->{ad_history}} == 0) {
-    # That's OK, no additional tests required
-  } elsif (@{$self->{ad_history}} == 2) {
-    my @non_number = grep !/^-?\d+$/, @{$self->{ad_history}};
-    if (@non_number) {
-      my $msg;
-      { local $" = ')(';
-        $msg = "ad_history contains non-numbers (@{$self->{ad_history}})";
-      }
-      _ci_warn($msg);
-      $good = 0;
-    } elsif ($self->{ad_history}[1] < $self->{ad_history}[0]) {
-      _ci_warn("ad_history has nonsensical values @{$self->{ad_history}}");
-      $good = 0;
-    }
-  } else {
-    _ci_warn("ad_history has bad length <@{$self->{ad_history}}>");
-    $good = 0;
-  }
-
-  $good;
-}
-
-################################################################
-#
-# Tie::File::Cache
-#
-# Read cache
-
-package Tie::File::Cache;
-$Tie::File::Cache::VERSION = $Tie::File::VERSION;
-use Carp ':DEFAULT', 'confess';
-
-sub HEAP () { 0 }
-sub HASH () { 1 }
-sub MAX  () { 2 }
-sub BYTES() { 3 }
-#sub STAT () { 4 } # Array with request statistics for each record
-#sub MISS () { 5 } # Total number of cache misses
-#sub REQ  () { 6 } # Total number of cache requests 
-use strict 'vars';
-
-sub new {
-  my ($pack, $max) = @_;
-  local *_;
-  croak "missing argument to ->new" unless defined $max;
-  my $self = [];
-  bless $self => $pack;
-  @$self = (Tie::File::Heap->new($self), {}, $max, 0);
-  $self;
-}
-
-sub adj_limit {
-  my ($self, $n) = @_;
-  $self->[MAX] += $n;
-}
-
-sub set_limit {
-  my ($self, $n) = @_;
-  $self->[MAX] = $n;
-}
-
-# For internal use only
-# Will be called by the heap structure to notify us that a certain 
-# piece of data has moved from one heap element to another.
-# $k is the hash key of the item
-# $n is the new index into the heap at which it is stored
-# If $n is undefined, the item has been removed from the heap.
-sub _heap_move {
-  my ($self, $k, $n) = @_;
-  if (defined $n) {
-    $self->[HASH]{$k} = $n;
-  } else {
-    delete $self->[HASH]{$k};
-  }
-}
-
-sub insert {
-  my ($self, $key, $val) = @_;
-  local *_;
-  croak "missing argument to ->insert" unless defined $key;
-  unless (defined $self->[MAX]) {
-    confess "undefined max" ;
-  }
-  confess "undefined val" unless defined $val;
-  return if length($val) > $self->[MAX];
-
-#  if ($self->[STAT]) {
-#    $self->[STAT][$key] = 1;
-#    return;
-#  }
-
-  my $oldnode = $self->[HASH]{$key};
-  if (defined $oldnode) {
-    my $oldval = $self->[HEAP]->set_val($oldnode, $val);
-    $self->[BYTES] -= length($oldval);
-  } else {
-    $self->[HEAP]->insert($key, $val);
-  }
-  $self->[BYTES] += length($val);
-  $self->flush if $self->[BYTES] > $self->[MAX];
-}
-
-sub expire {
-  my $self = shift;
-  my $old_data = $self->[HEAP]->popheap;
-  return unless defined $old_data;
-  $self->[BYTES] -= length $old_data;
-  $old_data;
-}
-
-sub remove {
-  my ($self, @keys) = @_;
-  my @result;
-
-#  if ($self->[STAT]) {
-#    for my $key (@keys) {
-#      $self->[STAT][$key] = 0;
-#    }
-#    return;
-#  }
-
-  for my $key (@keys) {
-    next unless exists $self->[HASH]{$key};
-    my $old_data = $self->[HEAP]->remove($self->[HASH]{$key});
-    $self->[BYTES] -= length $old_data;
-    push @result, $old_data;
-  }
-  @result;
-}
-
-sub lookup {
-  my ($self, $key) = @_;
-  local *_;
-  croak "missing argument to ->lookup" unless defined $key;
-
-#  if ($self->[STAT]) {
-#    $self->[MISS]++  if $self->[STAT][$key]++ == 0;
-#    $self->[REQ]++;
-#    my $hit_rate = 1 - $self->[MISS] / $self->[REQ];
-#    # Do some testing to determine this threshhold
-#    $#$self = STAT - 1 if $hit_rate > 0.20; 
-#  }
-
-  if (exists $self->[HASH]{$key}) {
-    $self->[HEAP]->lookup($self->[HASH]{$key});
-  } else {
-    return;
-  }
-}
-
-# For internal use only
-sub _produce {
-  my ($self, $key) = @_;
-  my $loc = $self->[HASH]{$key};
-  return unless defined $loc;
-  $self->[HEAP][$loc][2];
-}
-
-# For internal use only
-sub _promote {
-  my ($self, $key) = @_;
-  $self->[HEAP]->promote($self->[HASH]{$key});
-}
-
-sub empty {
-  my ($self) = @_;
-  %{$self->[HASH]} = ();
-    $self->[BYTES] = 0;
-    $self->[HEAP]->empty;
-#  @{$self->[STAT]} = ();
-#    $self->[MISS] = 0;
-#    $self->[REQ] = 0;
-}
-
-sub is_empty {
-  my ($self) = @_;
-  keys %{$self->[HASH]} == 0;
-}
-
-sub update {
-  my ($self, $key, $val) = @_;
-  local *_;
-  croak "missing argument to ->update" unless defined $key;
-  if (length($val) > $self->[MAX]) {
-    my ($oldval) = $self->remove($key);
-    $self->[BYTES] -= length($oldval) if defined $oldval;
-  } elsif (exists $self->[HASH]{$key}) {
-    my $oldval = $self->[HEAP]->set_val($self->[HASH]{$key}, $val);
-    $self->[BYTES] += length($val);
-    $self->[BYTES] -= length($oldval) if defined $oldval;
-  } else {
-    $self->[HEAP]->insert($key, $val);
-    $self->[BYTES] += length($val);
-  }
-  $self->flush;
-}
-
-sub rekey {
-  my ($self, $okeys, $nkeys) = @_;
-  local *_;
-  my %map;
-  @map{@$okeys} = @$nkeys;
-  croak "missing argument to ->rekey" unless defined $nkeys;
-  croak "length mismatch in ->rekey arguments" unless @$nkeys == @$okeys;
-  my %adjusted;                 # map new keys to heap indices
-  # You should be able to cut this to one loop TODO XXX
-  for (0 .. $#$okeys) {
-    $adjusted{$nkeys->[$_]} = delete $self->[HASH]{$okeys->[$_]};
-  }
-  while (my ($nk, $ix) = each %adjusted) {
-    # @{$self->[HASH]}{keys %adjusted} = values %adjusted;
-    $self->[HEAP]->rekey($ix, $nk);
-    $self->[HASH]{$nk} = $ix;
-  }
-}
-
-sub ckeys {
-  my $self = shift;
-  my @a = keys %{$self->[HASH]};
-  @a;
-}
-
-# Return total amount of cached data
-sub bytes {
-  my $self = shift;
-  $self->[BYTES];
-}
-
-# Expire oldest item from cache until cache size is smaller than $max
-sub reduce_size_to {
-  my ($self, $max) = @_;
-  until ($self->[BYTES] <= $max) {
-    # Note that Tie::File::Cache::expire has been inlined here
-    my $old_data = $self->[HEAP]->popheap;
-    return unless defined $old_data;
-    $self->[BYTES] -= length $old_data;
-  }
-}
-
-# Why not just $self->reduce_size_to($self->[MAX])?
-# Try this when things stabilize   TODO XXX
-# If the cache is too full, expire the oldest records
-sub flush {
-  my $self = shift;
-  $self->reduce_size_to($self->[MAX]) if $self->[BYTES] > $self->[MAX];
-}
-
-# For internal use only
-sub _produce_lru {
-  my $self = shift;
-  $self->[HEAP]->expire_order;
-}
-
-BEGIN { *_ci_warn = \&Tie::File::_ci_warn }
-
-sub _check_integrity {          # For CACHE
-  my $self = shift;
-  my $good = 1;
-
-  # Test HEAP
-  $self->[HEAP]->_check_integrity or $good = 0;
-
-  # Test HASH
-  my $bytes = 0;
-  for my $k (keys %{$self->[HASH]}) {
-    if ($k ne '0' && $k !~ /^[1-9][0-9]*$/) {
-      $good = 0;
-      _ci_warn "Cache hash key <$k> is non-numeric";
-    }
-
-    my $h = $self->[HASH]{$k};
-    if (! defined $h) {
-      $good = 0;
-      _ci_warn "Heap index number for key $k is undefined";
-    } elsif ($h == 0) {
-      $good = 0;
-      _ci_warn "Heap index number for key $k is zero";
-    } else {
-      my $j = $self->[HEAP][$h];
-      if (! defined $j) {
-        $good = 0;
-        _ci_warn "Heap contents key $k (=> $h) are undefined";
-      } else {
-        $bytes += length($j->[2]);
-        if ($k ne $j->[1]) {
-          $good = 0;
-          _ci_warn "Heap contents key $k (=> $h) is $j->[1], should be $k";
-        }
-      }
-    }
-  }
-
-  # Test BYTES
-  if ($bytes != $self->[BYTES]) {
-    $good = 0;
-    _ci_warn "Total data in cache is $bytes, expected $self->[BYTES]";
-  }
-
-  # Test MAX
-  if ($bytes > $self->[MAX]) {
-    $good = 0;
-    _ci_warn "Total data in cache is $bytes, exceeds maximum $self->[MAX]";
-  }
-
-  return $good;
-}
-
-sub delink {
-  my $self = shift;
-  $self->[HEAP] = undef;        # Bye bye heap
-}
-
-################################################################
-#
-# Tie::File::Heap
-#
-# Heap data structure for use by cache LRU routines
-
-package Tie::File::Heap;
-use Carp ':DEFAULT', 'confess';
-$Tie::File::Heap::VERSION = $Tie::File::Cache::VERSION;
-sub SEQ () { 0 };
-sub KEY () { 1 };
-sub DAT () { 2 };
-
-sub new {
-  my ($pack, $cache) = @_;
-  die "$pack: Parent cache object $cache does not support _heap_move method"
-    unless eval { $cache->can('_heap_move') };
-  my $self = [[0,$cache,0]];
-  bless $self => $pack;
-}
-
-# Allocate a new sequence number, larger than all previously allocated numbers
-sub _nseq {
-  my $self = shift;
-  $self->[0][0]++;
-}
-
-sub _cache {
-  my $self = shift;
-  $self->[0][1];
-}
-
-sub _nelts {
-  my $self = shift;
-  $self->[0][2];
-}
-
-sub _nelts_inc {
-  my $self = shift;
-  ++$self->[0][2];
-}  
-
-sub _nelts_dec {
-  my $self = shift;
-  --$self->[0][2];
-}  
-
-sub is_empty {
-  my $self = shift;
-  $self->_nelts == 0;
-}
-
-sub empty {
-  my $self = shift;
-  $#$self = 0;
-  $self->[0][2] = 0;
-  $self->[0][0] = 0;            # might as well reset the sequence numbers
-}
-
-# notify the parent cache object that we moved something
-sub _heap_move {
-  my $self = shift;
-  $self->_cache->_heap_move(@_);
-}
-
-# Insert a piece of data into the heap with the indicated sequence number.
-# The item with the smallest sequence number is always at the top.
-# If no sequence number is specified, allocate a new one and insert the
-# item at the bottom.
-sub insert {
-  my ($self, $key, $data, $seq) = @_;
-  $seq = $self->_nseq unless defined $seq;
-  $self->_insert_new([$seq, $key, $data]);
-}
-
-# Insert a new, fresh item at the bottom of the heap
-sub _insert_new {
-  my ($self, $item) = @_;
-  my $i = @$self;
-  $i = int($i/2) until defined $self->[$i/2];
-  $self->[$i] = $item;
-  $self->[0][1]->_heap_move($self->[$i][KEY], $i);
-  $self->_nelts_inc;
-}
-
-# Insert [$data, $seq] pair at or below item $i in the heap.
-# If $i is omitted, default to 1 (the top element.)
-sub _insert {
-  my ($self, $item, $i) = @_;
-#  $self->_check_loc($i) if defined $i;
-  $i = 1 unless defined $i;
-  until (! defined $self->[$i]) {
-    if ($self->[$i][SEQ] > $item->[SEQ]) { # inserted item is older
-      ($self->[$i], $item) = ($item, $self->[$i]);
-      $self->[0][1]->_heap_move($self->[$i][KEY], $i);
-    }
-    # If either is undefined, go that way.  Otherwise, choose at random
-    my $dir;
-    $dir = 0 if !defined $self->[2*$i];
-    $dir = 1 if !defined $self->[2*$i+1];
-    $dir = int(rand(2)) unless defined $dir;
-    $i = 2*$i + $dir;
-  }
-  $self->[$i] = $item;
-  $self->[0][1]->_heap_move($self->[$i][KEY], $i);
-  $self->_nelts_inc;
-}
-
-# Remove the item at node $i from the heap, moving child items upwards.
-# The item with the smallest sequence number is always at the top.
-# Moving items upwards maintains this condition.
-# Return the removed item.  Return undef if there was no item at node $i.
-sub remove {
-  my ($self, $i) = @_;
-  $i = 1 unless defined $i;
-  my $top = $self->[$i];
-  return unless defined $top;
-  while (1) {
-    my $ii;
-    my ($L, $R) = (2*$i, 2*$i+1);
-
-    # If either is undefined, go the other way.
-    # Otherwise, go towards the smallest.
-    last unless defined $self->[$L] || defined $self->[$R];
-    $ii = $R if not defined $self->[$L];
-    $ii = $L if not defined $self->[$R];
-    unless (defined $ii) {
-      $ii = $self->[$L][SEQ] < $self->[$R][SEQ] ? $L : $R;
-    }
-
-    $self->[$i] = $self->[$ii]; # Promote child to fill vacated spot
-    $self->[0][1]->_heap_move($self->[$i][KEY], $i);
-    $i = $ii; # Fill new vacated spot
-  }
-  $self->[0][1]->_heap_move($top->[KEY], undef);
-  undef $self->[$i];
-  $self->_nelts_dec;
-  return $top->[DAT];
-}
-
-sub popheap {
-  my $self = shift;
-  $self->remove(1);
-}
-
-# set the sequence number of the indicated item to a higher number
-# than any other item in the heap, and bubble the item down to the
-# bottom.
-sub promote {
-  my ($self, $n) = @_;
-#  $self->_check_loc($n);
-  $self->[$n][SEQ] = $self->_nseq;
-  my $i = $n;
-  while (1) {
-    my ($L, $R) = (2*$i, 2*$i+1);
-    my $dir;
-    last unless defined $self->[$L] || defined $self->[$R];
-    $dir = $R unless defined $self->[$L];
-    $dir = $L unless defined $self->[$R];
-    unless (defined $dir) {
-      $dir = $self->[$L][SEQ] < $self->[$R][SEQ] ? $L : $R;
-    }
-    @{$self}[$i, $dir] = @{$self}[$dir, $i];
-    for ($i, $dir) {
-      $self->[0][1]->_heap_move($self->[$_][KEY], $_) if defined $self->[$_];
-    }
-    $i = $dir;
-  }
-}
-
-# Return item $n from the heap, promoting its LRU status
-sub lookup {
-  my ($self, $n) = @_;
-#  $self->_check_loc($n);
-  my $val = $self->[$n];
-  $self->promote($n);
-  $val->[DAT];
-}
-
-
-# Assign a new value for node $n, promoting it to the bottom of the heap
-sub set_val {
-  my ($self, $n, $val) = @_;
-#  $self->_check_loc($n);
-  my $oval = $self->[$n][DAT];
-  $self->[$n][DAT] = $val;
-  $self->promote($n);
-  return $oval;
-}
-
-# The hask key has changed for an item;
-# alter the heap's record of the hash key
-sub rekey {
-  my ($self, $n, $new_key) = @_;
-#  $self->_check_loc($n);
-  $self->[$n][KEY] = $new_key;
-}
-
-sub _check_loc {
-  my ($self, $n) = @_;
-  unless (1 || defined $self->[$n]) {
-    confess "_check_loc($n) failed";
-  }
-}
-
-BEGIN { *_ci_warn = \&Tie::File::_ci_warn }
-
-sub _check_integrity {
-  my $self = shift;
-  my $good = 1;
-  my %seq;
-
-  unless (eval {$self->[0][1]->isa("Tie::File::Cache")}) {
-    _ci_warn "Element 0 of heap corrupt";
-    $good = 0;
-  }
-  $good = 0 unless $self->_satisfies_heap_condition(1);
-  for my $i (2 .. $#{$self}) {
-    my $p = int($i/2);          # index of parent node
-    if (defined $self->[$i] && ! defined $self->[$p]) {
-      _ci_warn "Element $i of heap defined, but parent $p isn't";
-      $good = 0;
-    }
-
-    if (defined $self->[$i]) {
-      if ($seq{$self->[$i][SEQ]}) {
-        my $seq = $self->[$i][SEQ];
-        _ci_warn "Nodes $i and $seq{$seq} both have SEQ=$seq";
-        $good = 0;
-      } else {
-        $seq{$self->[$i][SEQ]} = $i;
-      }
-    }
-  }
-
-  return $good;
-}
-
-sub _satisfies_heap_condition {
-  my $self = shift;
-  my $n = shift || 1;
-  my $good = 1;
-  for (0, 1) {
-    my $c = $n*2 + $_;
-    next unless defined $self->[$c];
-    if ($self->[$n][SEQ] >= $self->[$c]) {
-      _ci_warn "Node $n of heap does not predate node $c";
-      $good = 0 ;
-    }
-    $good = 0 unless $self->_satisfies_heap_condition($c);
-  }
-  return $good;
-}
-
-# Return a list of all the values, sorted by expiration order
-sub expire_order {
-  my $self = shift;
-  my @nodes = sort {$a->[SEQ] <=> $b->[SEQ]} $self->_nodes;
-  map { $_->[KEY] } @nodes;
-}
-
-sub _nodes {
-  my $self = shift;
-  my $i = shift || 1;
-  return unless defined $self->[$i];
-  ($self->[$i], $self->_nodes($i*2), $self->_nodes($i*2+1));
-}
-
-"Cogito, ergo sum.";  # don't forget to return a true value from the file
-
-__END__
-
-=head1 NAME
-
-Tie::File - Access the lines of a disk file via a Perl array
-
-=head1 SYNOPSIS
-
-	# This file documents Tie::File version 0.97
-	use Tie::File;
-
-	tie @array, 'Tie::File', filename or die ...;
-
-	$array[13] = 'blah';     # line 13 of the file is now 'blah'
-	print $array[42];        # display line 42 of the file
-
-	$n_recs = @array;        # how many records are in the file?
-	$#array -= 2;            # chop two records off the end
-
-
-	for (@array) {
-	  s/PERL/Perl/g;         # Replace PERL with Perl everywhere in the file
-	}
-
-	# These are just like regular push, pop, unshift, shift, and splice
-	# Except that they modify the file in the way you would expect
-
-	push @array, new recs...;
-	my $r1 = pop @array;
-	unshift @array, new recs...;
-	my $r2 = shift @array;
-	@old_recs = splice @array, 3, 7, new recs...;
-
-	untie @array;            # all finished
-
-
-=head1 DESCRIPTION
-
-C<Tie::File> represents a regular text file as a Perl array.  Each
-element in the array corresponds to a record in the file.  The first
-line of the file is element 0 of the array; the second line is element
-1, and so on.
-
-The file is I<not> loaded into memory, so this will work even for
-gigantic files.
-
-Changes to the array are reflected in the file immediately.
-
-Lazy people and beginners may now stop reading the manual.
-
-=head2 C<recsep>
-
-What is a 'record'?  By default, the meaning is the same as for the
-C<E<lt>...E<gt>> operator: It's a string terminated by C<$/>, which is
-probably C<"\n">.  (Minor exception: on DOS and Win32 systems, a
-'record' is a string terminated by C<"\r\n">.)  You may change the
-definition of "record" by supplying the C<recsep> option in the C<tie>
-call:
-
-	tie @array, 'Tie::File', $file, recsep => 'es';
-
-This says that records are delimited by the string C<es>.  If the file
-contained the following data:
-
-	Curse these pesky flies!\n
-
-then the C<@array> would appear to have four elements:
-
-	"Curse th"
-	"e p"
-	"ky fli"
-	"!\n"
-
-An undefined value is not permitted as a record separator.  Perl's
-special "paragraph mode" semantics (E<agrave> la C<$/ = "">) are not
-emulated.
-
-Records read from the tied array do not have the record separator
-string on the end; this is to allow
-
-	$array[17] .= "extra";
-
-to work as expected.
-
-(See L<"autochomp">, below.)  Records stored into the array will have
-the record separator string appended before they are written to the
-file, if they don't have one already.  For example, if the record
-separator string is C<"\n">, then the following two lines do exactly
-the same thing:
-
-	$array[17] = "Cherry pie";
-	$array[17] = "Cherry pie\n";
-
-The result is that the contents of line 17 of the file will be
-replaced with "Cherry pie"; a newline character will separate line 17
-from line 18.  This means that this code will do nothing:
-
-	chomp $array[17];
-
-Because the C<chomp>ed value will have the separator reattached when
-it is written back to the file.  There is no way to create a file
-whose trailing record separator string is missing.
-
-Inserting records that I<contain> the record separator string is not
-supported by this module.  It will probably produce a reasonable
-result, but what this result will be may change in a future version.
-Use 'splice' to insert records or to replace one record with several.
-
-=head2 C<autochomp>
-
-Normally, array elements have the record separator removed, so that if
-the file contains the text
-
-	Gold
-	Frankincense
-	Myrrh
-
-the tied array will appear to contain C<("Gold", "Frankincense",
-"Myrrh")>.  If you set C<autochomp> to a false value, the record
-separator will not be removed.  If the file above was tied with
-
-	tie @gifts, "Tie::File", $gifts, autochomp => 0;
-
-then the array C<@gifts> would appear to contain C<("Gold\n",
-"Frankincense\n", "Myrrh\n")>, or (on Win32 systems) C<("Gold\r\n",
-"Frankincense\r\n", "Myrrh\r\n")>.
-
-=head2 C<mode>
-
-Normally, the specified file will be opened for read and write access,
-and will be created if it does not exist.  (That is, the flags
-C<O_RDWR | O_CREAT> are supplied in the C<open> call.)  If you want to
-change this, you may supply alternative flags in the C<mode> option.
-See L<Fcntl> for a listing of available flags.
-For example:
-
-	# open the file if it exists, but fail if it does not exist
-	use Fcntl 'O_RDWR';
-	tie @array, 'Tie::File', $file, mode => O_RDWR;
-
-	# create the file if it does not exist
-	use Fcntl 'O_RDWR', 'O_CREAT';
-	tie @array, 'Tie::File', $file, mode => O_RDWR | O_CREAT;
-
-	# open an existing file in read-only mode
-	use Fcntl 'O_RDONLY';
-	tie @array, 'Tie::File', $file, mode => O_RDONLY;
-
-Opening the data file in write-only or append mode is not supported.
-
-=head2 C<memory>
-
-This is an upper limit on the amount of memory that C<Tie::File> will
-consume at any time while managing the file.  This is used for two
-things: managing the I<read cache> and managing the I<deferred write
-buffer>.
-
-Records read in from the file are cached, to avoid having to re-read
-them repeatedly.  If you read the same record twice, the first time it
-will be stored in memory, and the second time it will be fetched from
-the I<read cache>.  The amount of data in the read cache will not
-exceed the value you specified for C<memory>.  If C<Tie::File> wants
-to cache a new record, but the read cache is full, it will make room
-by expiring the least-recently visited records from the read cache.
-
-The default memory limit is 2Mib.  You can adjust the maximum read
-cache size by supplying the C<memory> option.  The argument is the
-desired cache size, in bytes.
-
-	# I have a lot of memory, so use a large cache to speed up access
-	tie @array, 'Tie::File', $file, memory => 20_000_000;
-
-Setting the memory limit to 0 will inhibit caching; records will be
-fetched from disk every time you examine them.
-
-The C<memory> value is not an absolute or exact limit on the memory
-used.  C<Tie::File> objects contains some structures besides the read
-cache and the deferred write buffer, whose sizes are not charged
-against C<memory>. 
-
-The cache itself consumes about 310 bytes per cached record, so if
-your file has many short records, you may want to decrease the cache
-memory limit, or else the cache overhead may exceed the size of the
-cached data.
-
-
-=head2 C<dw_size>
-
-(This is an advanced feature.  Skip this section on first reading.)
-
-If you use deferred writing (See L<"Deferred Writing">, below) then
-data you write into the array will not be written directly to the
-file; instead, it will be saved in the I<deferred write buffer> to be
-written out later.  Data in the deferred write buffer is also charged
-against the memory limit you set with the C<memory> option.
-
-You may set the C<dw_size> option to limit the amount of data that can
-be saved in the deferred write buffer.  This limit may not exceed the
-total memory limit.  For example, if you set C<dw_size> to 1000 and
-C<memory> to 2500, that means that no more than 1000 bytes of deferred
-writes will be saved up.  The space available for the read cache will
-vary, but it will always be at least 1500 bytes (if the deferred write
-buffer is full) and it could grow as large as 2500 bytes (if the
-deferred write buffer is empty.)
-
-If you don't specify a C<dw_size>, it defaults to the entire memory
-limit.
-
-=head2 Option Format
-
-C<-mode> is a synonym for C<mode>.  C<-recsep> is a synonym for
-C<recsep>.  C<-memory> is a synonym for C<memory>.  You get the
-idea.
-
-=head1 Public Methods
-
-The C<tie> call returns an object, say C<$o>.  You may call
-
-	$rec = $o->FETCH($n);
-	$o->STORE($n, $rec);
-
-to fetch or store the record at line C<$n>, respectively; similarly
-the other tied array methods.  (See L<perltie> for details.)  You may
-also call the following methods on this object:
-
-=head2 C<flock>
-
-	$o->flock(MODE)
-
-will lock the tied file.  C<MODE> has the same meaning as the second
-argument to the Perl built-in C<flock> function; for example
-C<LOCK_SH> or C<LOCK_EX | LOCK_NB>.  (These constants are provided by
-the C<use Fcntl ':flock'> declaration.)
-
-C<MODE> is optional; the default is C<LOCK_EX>.
-
-C<Tie::File> maintains an internal table of the byte offset of each
-record it has seen in the file.  
-
-When you use C<flock> to lock the file, C<Tie::File> assumes that the
-read cache is no longer trustworthy, because another process might
-have modified the file since the last time it was read.  Therefore, a
-successful call to C<flock> discards the contents of the read cache
-and the internal record offset table.
-
-C<Tie::File> promises that the following sequence of operations will
-be safe:
-
-	my $o = tie @array, "Tie::File", $filename;
-	$o->flock;
-
-In particular, C<Tie::File> will I<not> read or write the file during
-the C<tie> call.  (Exception: Using C<mode =E<gt> O_TRUNC> will, of
-course, erase the file during the C<tie> call.  If you want to do this
-safely, then open the file without C<O_TRUNC>, lock the file, and use
-C<@array = ()>.)
-
-The best way to unlock a file is to discard the object and untie the
-array.  It is probably unsafe to unlock the file without also untying
-it, because if you do, changes may remain unwritten inside the object.
-That is why there is no shortcut for unlocking.  If you really want to
-unlock the file prematurely, you know what to do; if you don't know
-what to do, then don't do it.
-
-All the usual warnings about file locking apply here.  In particular,
-note that file locking in Perl is B<advisory>, which means that
-holding a lock will not prevent anyone else from reading, writing, or
-erasing the file; it only prevents them from getting another lock at
-the same time.  Locks are analogous to green traffic lights: If you
-have a green light, that does not prevent the idiot coming the other
-way from plowing into you sideways; it merely guarantees to you that
-the idiot does not also have a green light at the same time.
-
-=head2 C<autochomp>
-
-	my $old_value = $o->autochomp(0);    # disable autochomp option
-	my $old_value = $o->autochomp(1);    #  enable autochomp option
-
-	my $ac = $o->autochomp();   # recover current value
-
-See L<"autochomp">, above.
-
-=head2 C<defer>, C<flush>, C<discard>, and C<autodefer>
-
-See L<"Deferred Writing">, below.
-
-=head2 C<offset>
-
-	$off = $o->offset($n);
-
-This method returns the byte offset of the start of the C<$n>th record
-in the file.  If there is no such record, it returns an undefined
-value.
-
-=head1 Tying to an already-opened filehandle
-
-If C<$fh> is a filehandle, such as is returned by C<IO::File> or one
-of the other C<IO> modules, you may use:
-
-	tie @array, 'Tie::File', $fh, ...;
-
-Similarly if you opened that handle C<FH> with regular C<open> or
-C<sysopen>, you may use:
-
-	tie @array, 'Tie::File', \*FH, ...;
-
-Handles that were opened write-only won't work.  Handles that were
-opened read-only will work as long as you don't try to modify the
-array.  Handles must be attached to seekable sources of data---that
-means no pipes or sockets.  If C<Tie::File> can detect that you
-supplied a non-seekable handle, the C<tie> call will throw an
-exception.  (On Unix systems, it can detect this.)
-
-Note that Tie::File will only close any filehandles that it opened
-internally.  If you passed it a filehandle as above, you "own" the
-filehandle, and are responsible for closing it after you have untied
-the @array.
-
-=head1 Deferred Writing
-
-(This is an advanced feature.  Skip this section on first reading.)
-
-Normally, modifying a C<Tie::File> array writes to the underlying file
-immediately.  Every assignment like C<$a[3] = ...> rewrites as much of
-the file as is necessary; typically, everything from line 3 through
-the end will need to be rewritten.  This is the simplest and most
-transparent behavior.  Performance even for large files is reasonably
-good.
-
-However, under some circumstances, this behavior may be excessively
-slow.  For example, suppose you have a million-record file, and you
-want to do:
-
-	for (@FILE) {
-	  $_ = "> $_";
-	}
-
-The first time through the loop, you will rewrite the entire file,
-from line 0 through the end.  The second time through the loop, you
-will rewrite the entire file from line 1 through the end.  The third
-time through the loop, you will rewrite the entire file from line 2 to
-the end.  And so on.
-
-If the performance in such cases is unacceptable, you may defer the
-actual writing, and then have it done all at once.  The following loop
-will perform much better for large files:
-
-	(tied @a)->defer;
-	for (@a) {
-	  $_ = "> $_";
-	}
-	(tied @a)->flush;
-
-If C<Tie::File>'s memory limit is large enough, all the writing will
-done in memory.  Then, when you call C<-E<gt>flush>, the entire file
-will be rewritten in a single pass.
-
-(Actually, the preceding discussion is something of a fib.  You don't
-need to enable deferred writing to get good performance for this
-common case, because C<Tie::File> will do it for you automatically
-unless you specifically tell it not to.  See L<"autodeferring">,
-below.)
-
-Calling C<-E<gt>flush> returns the array to immediate-write mode.  If
-you wish to discard the deferred writes, you may call C<-E<gt>discard>
-instead of C<-E<gt>flush>.  Note that in some cases, some of the data
-will have been written already, and it will be too late for
-C<-E<gt>discard> to discard all the changes.  Support for
-C<-E<gt>discard> may be withdrawn in a future version of C<Tie::File>.
-
-Deferred writes are cached in memory up to the limit specified by the
-C<dw_size> option (see above).  If the deferred-write buffer is full
-and you try to write still more deferred data, the buffer will be
-flushed.  All buffered data will be written immediately, the buffer
-will be emptied, and the now-empty space will be used for future
-deferred writes.
-
-If the deferred-write buffer isn't yet full, but the total size of the
-buffer and the read cache would exceed the C<memory> limit, the oldest
-records will be expired from the read cache until the total size is
-under the limit.
-
-C<push>, C<pop>, C<shift>, C<unshift>, and C<splice> cannot be
-deferred.  When you perform one of these operations, any deferred data
-is written to the file and the operation is performed immediately.
-This may change in a future version.
-
-If you resize the array with deferred writing enabled, the file will
-be resized immediately, but deferred records will not be written.
-This has a surprising consequence: C<@a = (...)> erases the file
-immediately, but the writing of the actual data is deferred.  This
-might be a bug.  If it is a bug, it will be fixed in a future version.
-
-=head2 Autodeferring
-
-C<Tie::File> tries to guess when deferred writing might be helpful,
-and to turn it on and off automatically. 
-
-	for (@a) {
-	  $_ = "> $_";
-	}
-
-In this example, only the first two assignments will be done
-immediately; after this, all the changes to the file will be deferred
-up to the user-specified memory limit.
-
-You should usually be able to ignore this and just use the module
-without thinking about deferring.  However, special applications may
-require fine control over which writes are deferred, or may require
-that all writes be immediate.  To disable the autodeferment feature,
-use
-
-	(tied @o)->autodefer(0);
-
-or
-
-       	tie @array, 'Tie::File', $file, autodefer => 0;
-
-
-Similarly, C<-E<gt>autodefer(1)> re-enables autodeferment, and 
-C<-E<gt>autodefer()> recovers the current value of the autodefer setting.
-
-
-=head1 CONCURRENT ACCESS TO FILES
-
-Caching and deferred writing are inappropriate if you want the same
-file to be accessed simultaneously from more than one process.  Other
-optimizations performed internally by this module are also
-incompatible with concurrent access.  A future version of this module will
-support a C<concurrent =E<gt> 1> option that enables safe concurrent access.
-
-Previous versions of this documentation suggested using C<memory
-=E<gt> 0> for safe concurrent access.  This was mistaken.  Tie::File
-will not support safe concurrent access before version 0.98.
-
-=head1 CAVEATS
-
-(That's Latin for 'warnings'.)
-
-=over 4
-
-=item *
-
-Reasonable effort was made to make this module efficient.  Nevertheless,
-changing the size of a record in the middle of a large file will
-always be fairly slow, because everything after the new record must be
-moved.
-
-=item *
-
-The behavior of tied arrays is not precisely the same as for regular
-arrays.  For example:
-
-	# This DOES print "How unusual!"
-	undef $a[10];  print "How unusual!\n" if defined $a[10];
-
-C<undef>-ing a C<Tie::File> array element just blanks out the
-corresponding record in the file.  When you read it back again, you'll
-get the empty string, so the supposedly-C<undef>'ed value will be
-defined.  Similarly, if you have C<autochomp> disabled, then
-
-	# This DOES print "How unusual!" if 'autochomp' is disabled
-	undef $a[10];
-        print "How unusual!\n" if $a[10];
-
-Because when C<autochomp> is disabled, C<$a[10]> will read back as
-C<"\n"> (or whatever the record separator string is.)  
-
-There are other minor differences, particularly regarding C<exists>
-and C<delete>, but in general, the correspondence is extremely close.
-
-=item *
-
-I have supposed that since this module is concerned with file I/O,
-almost all normal use of it will be heavily I/O bound.  This means
-that the time to maintain complicated data structures inside the
-module will be dominated by the time to actually perform the I/O.
-When there was an opportunity to spend CPU time to avoid doing I/O, I
-usually tried to take it.
-
-=item *
-
-You might be tempted to think that deferred writing is like
-transactions, with C<flush> as C<commit> and C<discard> as
-C<rollback>, but it isn't, so don't.
-
-=item *
-
-There is a large memory overhead for each record offset and for each
-cache entry: about 310 bytes per cached data record, and about 21 bytes per offset table entry.
-
-The per-record overhead will limit the maximum number of records you
-can access per file. Note that I<accessing> the length of the array
-via C<$x = scalar @tied_file> accesses B<all> records and stores their
-offsets.  The same for C<foreach (@tied_file)>, even if you exit the
-loop early.
-
-=back
-
-=head1 SUBCLASSING
-
-This version promises absolutely nothing about the internals, which
-may change without notice.  A future version of the module will have a
-well-defined and stable subclassing API.
-
-=head1 WHAT ABOUT C<DB_File>?
-
-People sometimes point out that L<DB_File> will do something similar,
-and ask why C<Tie::File> module is necessary.
-
-There are a number of reasons that you might prefer C<Tie::File>.
-A list is available at C<http://perl.plover.com/TieFile/why-not-DB_File>.
-
-=head1 AUTHOR
-
-Mark Jason Dominus
-
-To contact the author, send email to: C<mjd-perl-tiefile+@plover.com>
-
-To receive an announcement whenever a new version of this module is
-released, send a blank email message to
-C<mjd-perl-tiefile-subscribe@plover.com>.
-
-The most recent version of this module, including documentation and
-any news of importance, will be available at
-
-	http://perl.plover.com/TieFile/
-
-
-=head1 LICENSE
-
-C<Tie::File> version 0.97 is copyright (C) 2003 Mark Jason Dominus.
-
-This library is free software; you may redistribute it and/or modify
-it under the same terms as Perl itself.
-
-These terms are your choice of any of (1) the Perl Artistic Licence,
-or (2) version 2 of the GNU General Public License as published by the
-Free Software Foundation, or (3) any later version of the GNU General
-Public License.
-
-This library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this library program; it should be in the file C<COPYING>.
-If not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA  02110-1301, USA
-
-For licensing inquiries, contact the author at:
-
-	Mark Jason Dominus
-	255 S. Warnock St.
-	Philadelphia, PA 19107
-
-=head1 WARRANTY
-
-C<Tie::File> version 0.97 comes with ABSOLUTELY NO WARRANTY.
-For details, see the license.
-
-=head1 THANKS
-
-Gigantic thanks to Jarkko Hietaniemi, for agreeing to put this in the
-core when I hadn't written it yet, and for generally being helpful,
-supportive, and competent.  (Usually the rule is "choose any one.")
-Also big thanks to Abhijit Menon-Sen for all of the same things.
-
-Special thanks to Craig Berry and Peter Prymmer (for VMS portability
-help), Randy Kobes (for Win32 portability help), Clinton Pierce and
-Autrijus Tang (for heroic eleventh-hour Win32 testing above and beyond
-the call of duty), Michael G Schwern (for testing advice), and the
-rest of the CPAN testers (for testing generally).
-
-Special thanks to Tels for suggesting several speed and memory
-optimizations.
-
-Additional thanks to:
-Edward Avis /
-Mattia Barbon /
-Tom Christiansen /
-Gerrit Haase /
-Gurusamy Sarathy /
-Jarkko Hietaniemi (again) /
-Nikola Knezevic /
-John Kominetz /
-Nick Ing-Simmons /
-Tassilo von Parseval /
-H. Dieter Pearcey /
-Slaven Rezic /
-Eric Roode /
-Peter Scott /
-Peter Somu /
-Autrijus Tang (again) /
-Tels (again) /
-Juerd Waalboer
-
-=head1 TODO
-
-More tests.  (Stuff I didn't think of yet.)
-
-Paragraph mode?
-
-Fixed-length mode.  Leave-blanks mode.
-
-Maybe an autolocking mode?
-
-For many common uses of the module, the read cache is a liability.
-For example, a program that inserts a single record, or that scans the
-file once, will have a cache hit rate of zero.  This suggests a major
-optimization: The cache should be initially disabled.  Here's a hybrid
-approach: Initially, the cache is disabled, but the cache code
-maintains statistics about how high the hit rate would be *if* it were
-enabled.  When it sees the hit rate get high enough, it enables
-itself.  The STAT comments in this code are the beginning of an
-implementation of this.
-
-Record locking with fcntl()?  Then the module might support an undo
-log and get real transactions.  What a tour de force that would be.
-
-Keeping track of the highest cached record. This would allow reads-in-a-row
-to skip the cache lookup faster (if reading from 1..N with empty cache at
-start, the last cached value will be always N-1).
-
-More tests.
-
-=cut
-
diff --git a/ext/Tie-File/t/00_version.t b/ext/Tie-File/t/00_version.t
deleted file mode 100644
index f98523a0e1..0000000000
--- a/ext/Tie-File/t/00_version.t
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/perl
-
-print "1..1\n";
-
-my $testversion = "0.97_01";
-use Tie::File;
-
-if ($Tie::File::VERSION != $testversion) {
-  print STDERR "
-
-*** WHOA THERE!!! ***
-
-You seem to be running version $Tie::File::VERSION of the module
-against version $testversion of the test suite!
-
-None of the other test results will be reliable.
-";
-  exit 1;
-}
-
-print "ok 1\n";
-
diff --git a/ext/Tie-File/t/01_gen.t b/ext/Tie-File/t/01_gen.t
deleted file mode 100644
index 202b09c76a..0000000000
--- a/ext/Tie-File/t/01_gen.t
+++ /dev/null
@@ -1,165 +0,0 @@
-#!/usr/bin/perl
-
-$| = 1;
-my $file = "tf$$.txt";
-1 while unlink $file;
-
-print "1..75\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-my $o = tie @a, 'Tie::File', $file, autochomp => 0, autodefer => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-$: = $o->{recsep};
-
-# 3-5 create
-$a[0] = 'rec0';
-check_contents("rec0");
-
-# 6-11 append
-$a[1] = 'rec1';
-check_contents("rec0", "rec1");
-$a[2] = 'rec2';
-check_contents("rec0", "rec1", "rec2");
-
-# 12-20 same-length alterations
-$a[0] = 'new0';
-check_contents("new0", "rec1", "rec2");
-$a[1] = 'new1';
-check_contents("new0", "new1", "rec2");
-$a[2] = 'new2';
-check_contents("new0", "new1", "new2");
-
-# 21-35 lengthening alterations
-$a[0] = 'long0';
-check_contents("long0", "new1", "new2");
-$a[1] = 'long1';
-check_contents("long0", "long1", "new2");
-$a[2] = 'long2';
-check_contents("long0", "long1", "long2");
-$a[1] = 'longer1';
-check_contents("long0", "longer1", "long2");
-$a[0] = 'longer0';
-check_contents("longer0", "longer1", "long2");
-
-# 36-50 shortening alterations, including truncation
-$a[0] = 'short0';
-check_contents("short0", "longer1", "long2");
-$a[1] = 'short1';
-check_contents("short0", "short1", "long2");
-$a[2] = 'short2';
-check_contents("short0", "short1", "short2");
-$a[1] = 'sh1';
-check_contents("short0", "sh1", "short2");
-$a[0] = 'sh0';
-check_contents("sh0", "sh1", "short2");
-
-# (51-56) file with holes
-$a[4] = 'rec4';
-check_contents("sh0", "sh1", "short2", "", "rec4");
-$a[3] = 'rec3';
-check_contents("sh0", "sh1", "short2", "rec3", "rec4");
-
-# (57-59) zero out file
-@a = ();
-check_contents();
-
-# (60-62) insert into the middle of an empty file
-$a[3] = "rec3";
-check_contents("", "", "", "rec3");
-
-# (63-68) 20020326 You thought there would be a bug in STORE where if
-# a cached record was false, STORE wouldn't see it at all.  But you
-# forgot that records always come back from the cache with the record
-# separator attached, so they are unlikely to be false.  The only
-# really weird case is when the cached record is empty and the record
-# separator is "0".  Test that in 09_gen_rs.t.
-$a[1] = "0";
-check_contents("", "0", "", "rec3");
-$a[1] = "whoops";
-check_contents("", "whoops", "", "rec3");
-
-# (69-72) make sure that undefs are treated correctly---they should 
-# be converted to empty records, and should not raise any warnings.
-# (Some of these failed in 0.90.  The change to _fixrec fixed them.)
-# 20020331
-{
-  my $good = 1; my $warn;
-  # If any of these raise warnings, we have a problem.
-  local $SIG{__WARN__} = sub { $good = 0; $warn = shift(); ctrlfix($warn)};
-  local $^W = 1;
-  @a = (1);
-  $a[0] = undef;
-  print $good ? "ok $N\n" : "not ok $N # $warn\n";
-  $N++; $good = 1;
-  print defined($a[0]) ? "ok $N\n" : "not ok $N\n";
-  $N++; $good = 1;
-  $a[3] = '3';
-  print defined($a[1]) ? "ok $N\n" : "not ok $N\n";
-  $N++; $good = 1;
-  undef $a[3];
-  print $good ? "ok $N\n" : "not ok $N # $warn\n";
-  $N++; $good = 1;
-}
-
-# (73-75) What if the user has tampered with $\ ?
-{ {  local $\ = "stop messing with the funny variables!";
-     @a = (0..2);
-   }
-  check_contents(0..2);
-}
-
-use POSIX 'SEEK_SET';
-sub check_contents {
-  my @c = @_;
-  my $x = join $:, @c, '';
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-#  my $open = open FH, "< $file";
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix($a, $x);
-    print "not ok $N\n# expected <$x>, got <$a>\n";
-  }
-  $N++;
-
-  # now check FETCH:
-  my $good = 1;
-  my $msg;
-  for (0.. $#c) {
-    my $aa = $a[$_];
-    unless ($aa eq "$c[$_]$:") {
-      $msg = "expected <$c[$_]$:>, got <$aa>";
-      ctrlfix($msg);
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N # $msg\n";
-  $N++;
-
-  print $o->_check_integrity($file, $ENV{INTEGRITY}) 
-      ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/02_fetchsize.t b/ext/Tie-File/t/02_fetchsize.t
deleted file mode 100644
index 12d2b51cba..0000000000
--- a/ext/Tie-File/t/02_fetchsize.t
+++ /dev/null
@@ -1,53 +0,0 @@
-#!/usr/bin/perl
-
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-my $data = "rec1$:rec2$:rec3$:";
-
-print "1..6\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-open F, "> $file" or die $!;
-binmode F;
-print F $data;
-close F;
-
-
-my $o = tie @a, 'Tie::File', $file, autochomp => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-$: = $o->{recsep};
-
-my $n;
-
-# 3  test array element count
-$n = @a;
-print $n == 3 ? "ok $N\n" : "not ok $N # n=$n\n";
-$N++;
-
-# 4 same thing again   
-$n = @a;
-print $n == 3 ? "ok $N\n" : "not ok $N # n=$n\n";
-$N++;
-
-# 5  test $#a notation
-$n = $#a;
-print $n == 2 ? "ok $N\n" : "not ok $N # n=$n\n";
-$N++;
-
-# 6  test looping over array elements
-my $q;
-for (@a) { $q .= $_ }
-print $q eq $data ? "ok $N\n" : "not ok $N # n=$n\n";
-$N++;
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/03_longfetch.t b/ext/Tie-File/t/03_longfetch.t
deleted file mode 100644
index 7d5a3886fe..0000000000
--- a/ext/Tie-File/t/03_longfetch.t
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/perl
-#
-# Make sure we can fetch a record in the middle of the file
-# before we've ever looked at any records before it
-#
-# Make sure fetching past the end of the file returns the undefined value
-#
-# (tests _fill_offsets_to() )
-#
-
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-my $data = "rec0$:rec1$:rec2$:";
-
-print "1..8\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-open F, "> $file" or die $!;
-binmode F;
-print F $data;
-close F;
-
-
-my $o = tie @a, 'Tie::File', $file, autochomp => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-$: = $o->{recsep};
-
-my $n;
-
-# 3-5
-for (2, 1, 0) {
-  my $rec = $a[$_];
-  print $rec eq "rec$_$:" ? "ok $N\n" : "not ok $N # rec=<$rec> ?\n";
-  $N++;
-}
-
-# 6-8
-for (3, 4, 6) {
-  my $rec = $a[$_];
-  print ((not defined $rec) ? "ok $N\n" : "not ok $N # rec=<$rec> is defined\n");
-  $N++;
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/04_splice.t b/ext/Tie-File/t/04_splice.t
deleted file mode 100644
index b3880b758c..0000000000
--- a/ext/Tie-File/t/04_splice.t
+++ /dev/null
@@ -1,264 +0,0 @@
-#!/usr/bin/perl
-
-#
-# Check SPLICE function's effect on the file
-# (07_rv_splice.t checks its return value)
-#
-# Each call to 'check_contents' actually performs two tests.
-# First, it calls the tied object's own 'check_integrity' method,
-# which makes sure that the contents of the read cache and offset tables
-# accurately reflect the contents of the file.  
-# Then, it checks the actual contents of the file against the expected
-# contents.
-
-
-$| = 1;
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-my $data = "rec0$:rec1$:rec2$:";
-print "1..118\n";
-
-init_file($data);
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;  # partial credit just for showing up
-
-my $o = tie @a, 'Tie::File', $file;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-$: = $o->{recsep};
-my $n;
-
-# (3-22) splicing at the beginning
-splice(@a, 0, 0, "rec4");
-check_contents("rec4$:$data");
-splice(@a, 0, 1, "rec5");       # same length
-check_contents("rec5$:$data");
-splice(@a, 0, 1, "record5");    # longer
-check_contents("record5$:$data");
-
-splice(@a, 0, 1, "r5");         # shorter
-check_contents("r5$:$data");
-splice(@a, 0, 1);               # removal
-check_contents("$data");
-splice(@a, 0, 0);               # no-op
-check_contents("$data");
-splice(@a, 0, 0, 'r7', 'rec8'); # insert more than one
-check_contents("r7$:rec8$:$data");
-splice(@a, 0, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_contents("rec7$:record8$:rec9$:$data");
-
-splice(@a, 0, 3, 'record9', 'rec10'); # delete more than insert
-check_contents("record9$:rec10$:$data");
-splice(@a, 0, 2);               # delete more than one
-check_contents("$data");
-
-
-# (23-42) splicing in the middle
-splice(@a, 1, 0, "rec4");
-check_contents("rec0$:rec4$:rec1$:rec2$:");
-splice(@a, 1, 1, "rec5");       # same length
-check_contents("rec0$:rec5$:rec1$:rec2$:");
-splice(@a, 1, 1, "record5");    # longer
-check_contents("rec0$:record5$:rec1$:rec2$:");
-
-splice(@a, 1, 1, "r5");         # shorter
-check_contents("rec0$:r5$:rec1$:rec2$:");
-splice(@a, 1, 1);               # removal
-check_contents("$data");
-splice(@a, 1, 0);               # no-op
-check_contents("$data");
-splice(@a, 1, 0, 'r7', 'rec8'); # insert more than one
-check_contents("rec0$:r7$:rec8$:rec1$:rec2$:");
-splice(@a, 1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_contents("rec0$:rec7$:record8$:rec9$:rec1$:rec2$:");
-
-splice(@a, 1, 3, 'record9', 'rec10'); # delete more than insert
-check_contents("rec0$:record9$:rec10$:rec1$:rec2$:");
-splice(@a, 1, 2);               # delete more than one
-check_contents("$data");
-
-# (43-62) splicing at the end
-splice(@a, 3, 0, "rec4");
-check_contents("$ {data}rec4$:");
-splice(@a, 3, 1, "rec5");       # same length
-check_contents("$ {data}rec5$:");
-splice(@a, 3, 1, "record5");    # longer
-check_contents("$ {data}record5$:");
-
-splice(@a, 3, 1, "r5");         # shorter
-check_contents("$ {data}r5$:");
-splice(@a, 3, 1);               # removal
-check_contents("$data");
-splice(@a, 3, 0);               # no-op
-check_contents("$data");
-splice(@a, 3, 0, 'r7', 'rec8'); # insert more than one
-check_contents("$ {data}r7$:rec8$:");
-splice(@a, 3, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_contents("$ {data}rec7$:record8$:rec9$:");
-
-splice(@a, 3, 3, 'record9', 'rec10'); # delete more than insert
-check_contents("$ {data}record9$:rec10$:");
-splice(@a, 3, 2);               # delete more than one
-check_contents("$data");
-
-# (63-82) splicing with negative subscript
-splice(@a, -1, 0, "rec4");
-check_contents("rec0$:rec1$:rec4$:rec2$:");
-splice(@a, -1, 1, "rec5");       # same length
-check_contents("rec0$:rec1$:rec4$:rec5$:");
-splice(@a, -1, 1, "record5");    # longer
-check_contents("rec0$:rec1$:rec4$:record5$:");
-
-splice(@a, -1, 1, "r5");         # shorter
-check_contents("rec0$:rec1$:rec4$:r5$:");
-splice(@a, -1, 1);               # removal
-check_contents("rec0$:rec1$:rec4$:");
-splice(@a, -1, 0);               # no-op  
-check_contents("rec0$:rec1$:rec4$:");
-splice(@a, -1, 0, 'r7', 'rec8'); # insert more than one
-check_contents("rec0$:rec1$:r7$:rec8$:rec4$:");
-splice(@a, -1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_contents("rec0$:rec1$:r7$:rec8$:rec7$:record8$:rec9$:");
-
-splice(@a, -3, 3, 'record9', 'rec10'); # delete more than insert
-check_contents("rec0$:rec1$:r7$:rec8$:record9$:rec10$:");
-splice(@a, -4, 3);               # delete more than one
-check_contents("rec0$:rec1$:rec10$:");
-
-# (83-84) scrub it all out
-splice(@a, 0, 3);
-check_contents("");
-
-# (85-86) put some back in
-splice(@a, 0, 0, "rec0", "rec1");
-check_contents("rec0$:rec1$:");
-
-# (87-88) what if we remove too many records?
-splice(@a, 0, 17);
-check_contents("");
-
-# (89-92) In the past, splicing past the end was not correctly detected
-# (1.14)
-splice(@a, 89, 3);
-check_contents("");
-splice(@a, @a, 3);
-check_contents("");
-
-# (93-96) Also we did not emulate splice's freaky behavior when inserting
-# past the end of the array (1.14)
-splice(@a, 89, 0, "I", "like", "pie");
-check_contents("I$:like$:pie$:");
-splice(@a, 89, 0, "pie pie pie");
-check_contents("I$:like$:pie$:pie pie pie$:");
-
-# (97) Splicing with too large a negative number should be fatal
-# This test ignored because it causes 5.6.1 and 5.7.3 to dump core
-# It also garbles the stack under 5.005_03 (20020401)
-# NOT MY FAULT
-if ($] > 5.007003) {
-  eval { splice(@a, -7, 0) };
-  print $@ =~ /^Modification of non-creatable array value attempted, subscript -7/
-      ? "ok $N\n" : "not ok $N \# \$\@ was '$@'\n";
-} else { 
-  print "ok $N \# skipped (versions through 5.7.3 dump core here.)\n";
-}
-$N++;
-       
-# (98-101) Test default arguments
-splice @a, 0, 0, (0..11);
-splice @a, 4;
-check_contents("0$:1$:2$:3$:");
-splice @a;
-check_contents("");
-
-# (102-103) I think there's a bug here---it will fail to clear the EOF flag
-@a = (0..11);
-splice @a, -1, 1000;
-check_contents("0$:1$:2$:3$:4$:5$:6$:7$:8$:9$:10$:");
-
-# (104-106) make sure that undefs are treated correctly---they should
-# be converted to empty records, and should not raise any warnings.
-# (Some of these failed in 0.90.  The change to _fixrec fixed them.)
-# 20020331
-{
-  my $good = 1; my $warn;
-  # If any of these raise warnings, we have a problem.
-  local $SIG{__WARN__} = sub { $good = 0; $warn = shift(); ctrlfix($warn)};
-  local $^W = 1;
-  @a = (1);
-  splice @a, 1, 0, undef, undef, undef;
-  print $good ? "ok $N\n" : "not ok $N # $warn\n";
-  $N++; $good = 1;
-  print defined($a[2]) ? "ok $N\n" : "not ok $N\n";
-  $N++; $good = 1;
-  my @r = splice @a, 2;
-  print defined($r[0]) ? "ok $N\n" : "not ok $N\n";
-  $N++; $good = 1;
-}
-
-# (107-118) splice with negative length was treated wrong
-# 20020402 Reported by Juerd Waalboer
-@a = (0..8) ;
-splice @a, 0, -3;
-check_contents("6$:7$:8$:");
-@a = (0..8) ;
-splice @a, 1, -3;
-check_contents("0$:6$:7$:8$:");
-@a = (0..8) ;
-splice @a, 7, -3;
-check_contents("0$:1$:2$:3$:4$:5$:6$:7$:8$:");
-@a = (0..2) ;
-splice @a, 0, -3;
-check_contents("0$:1$:2$:");
-@a = (0..2) ;
-splice @a, 1, -3;
-check_contents("0$:1$:2$:");
-@a = (0..2) ;
-splice @a, 7, -3;
-check_contents("0$:1$:2$:");
-
-sub init_file {
-  my $data = shift;
-  open F, "> $file" or die $!;
-  binmode F;
-  print F $data;
-  close F;
-}
-
-use POSIX 'SEEK_SET';
-sub check_contents {
-  my $x = shift;
-  my $integrity = $o->_check_integrity($file, $ENV{INTEGRITY});
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-  print $integrity ? "ok $N\n" : "not ok $N\n";
-  $N++;
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix($a, $x);
-    print "not ok $N\n# expected <$x>, got <$a>\n";
-  }
-  $N++;
-}
-
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/05_size.t b/ext/Tie-File/t/05_size.t
deleted file mode 100644
index 44c69f910f..0000000000
--- a/ext/Tie-File/t/05_size.t
+++ /dev/null
@@ -1,129 +0,0 @@
-#!/usr/bin/perl
-#
-# Check FETCHSIZE and SETSIZE functions
-# PUSH POP SHIFT UNSHIFT
-#
-
-use POSIX 'SEEK_SET';
-
-my $file = "tf$$.txt";
-my ($o, $n);
-
-print "1..16\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-# 2-3 FETCHSIZE 0-length file
-open F, "> $file" or die $!;
-binmode F;
-close F;
-$o = tie @a, 'Tie::File', $file;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-$: = $o->{recsep};
-
-$n = @a;
-print $n == 0 ? "ok $N\n" : "not ok $N # $n, s/b 0\n";
-$N++;
-
-# Reset everything
-undef $o;
-untie @a;
-
-my $data = "rec0$:rec1$:rec2$:";
-open F, "> $file" or die $!;
-binmode F;
-print F $data;
-close F;
-
-$o = tie @a, 'Tie::File', $file;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# 4-5 FETCHSIZE positive-length file
-$n = @a;
-print $n == 3 ? "ok $N\n" : "not ok $N # $n, s/b 0\n";
-$N++;
-
-# STORESIZE
-# (6-7) Make it longer:
-populate();
-$#a = 4;
-check_contents("$data$:$:");
-
-# (8-9) Make it longer again:
-populate();
-$#a = 6;
-check_contents("$data$:$:$:$:");
-
-# (10-11) Make it shorter:
-populate();
-$#a = 4;
-check_contents("$data$:$:");
-
-# (12-13) Make it shorter again:
-populate();
-$#a = 2;
-check_contents($data);
-
-# (14-15) Get rid of it completely:
-populate();
-$#a = -1;
-check_contents('');
-
-# (16) 20020324 I have an idea that shortening the array will not
-# expunge a cached record at the end if one is present.
-$o->defer;
-$a[3] = "record";
-my $r = $a[3];
-$#a = -1;
-$r = $a[3];
-print (! defined $r ? "ok $N\n" : "not ok $N \# was <$r>; should be UNDEF\n");
-# Turns out not to be the case---STORESIZE explicitly removes them later
-# 20020326 Well, but happily, this test did fail today.
-
-# In the past, there was a bug in STORESIZE that it didn't correctly
-# remove deleted records from the cache.  This wasn't detected
-# because these tests were all done with an empty cache.  populate()
-# will ensure that the cache is fully populated.
-sub populate {
-  my $z;
-  $z = $a[$_] for 0 .. $#a;
-}
-
-sub check_contents {
-  my $x = shift;
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix($a, $x);
-    print "not ok $N\n# expected <$x>, got <$a>\n";
-  }
-  $N++;
-  my $integrity = $o->_check_integrity($file, $ENV{INTEGRITY});
-  print $integrity ? "ok $N\n" : "not ok $N \# integrity\n";
-  $N++;
-}
-
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/06_fixrec.t b/ext/Tie-File/t/06_fixrec.t
deleted file mode 100644
index bf24be1300..0000000000
--- a/ext/Tie-File/t/06_fixrec.t
+++ /dev/null
@@ -1,53 +0,0 @@
-#!/usr/bin/perl
-
-use POSIX 'SEEK_SET';
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-
-print "1..5\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-my $o = tie @a, 'Tie::File', $file, autodefer => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-$a[0] = 'rec0';
-check_contents("rec0$:");
-$a[1] = "rec1$:";
-check_contents("rec0$:rec1$:");
-$a[2] = "rec2$:$:";             # should we detect this?
-check_contents("rec0$:rec1$:rec2$:$:");
-
-sub check_contents {
-  my $x = shift;
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    my $msg = "not ok $N # expected <$x>, got <$a>";
-    ctrlfix($msg);
-    print "$msg\n";
-  }
-  $N++;
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/07_rv_splice.t b/ext/Tie-File/t/07_rv_splice.t
deleted file mode 100644
index e5c09b1a48..0000000000
--- a/ext/Tie-File/t/07_rv_splice.t
+++ /dev/null
@@ -1,205 +0,0 @@
-#!/usr/bin/perl
-#
-# Check SPLICE function's return value
-# (04_splice.t checks its effect on the file)
-#
-
-
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-my $data = "rec0$:rec1$:rec2$:";
-
-print "1..56\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;  # partial credit just for showing up
-
-init_file($data);
-
-my $o = tie @a, 'Tie::File', $file, autochomp => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-my $n;
-
-# (3-12) splicing at the beginning
-@r = splice(@a, 0, 0, "rec4");
-check_result();
-@r = splice(@a, 0, 1, "rec5");       # same length
-check_result("rec4");
-@r = splice(@a, 0, 1, "record5");    # longer
-check_result("rec5");
-
-@r = splice(@a, 0, 1, "r5");         # shorter
-check_result("record5");
-@r = splice(@a, 0, 1);               # removal
-check_result("r5");
-@r = splice(@a, 0, 0);               # no-op
-check_result();
-@r = splice(@a, 0, 0, 'r7', 'rec8'); # insert more than one
-check_result();
-@r = splice(@a, 0, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_result('r7', 'rec8');
-
-@r = splice(@a, 0, 3, 'record9', 'rec10'); # delete more than insert
-check_result('rec7', 'record8', 'rec9');
-@r = splice(@a, 0, 2);               # delete more than one
-check_result('record9', 'rec10');
-
-
-# (13-22) splicing in the middle
-@r = splice(@a, 1, 0, "rec4");
-check_result();
-@r = splice(@a, 1, 1, "rec5");       # same length
-check_result('rec4');
-@r = splice(@a, 1, 1, "record5");    # longer
-check_result('rec5');
-
-@r = splice(@a, 1, 1, "r5");         # shorter
-check_result("record5");
-@r = splice(@a, 1, 1);               # removal
-check_result("r5");
-@r = splice(@a, 1, 0);               # no-op
-check_result();
-@r = splice(@a, 1, 0, 'r7', 'rec8'); # insert more than one
-check_result();
-@r = splice(@a, 1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_result('r7', 'rec8');
-
-@r = splice(@a, 1, 3, 'record9', 'rec10'); # delete more than insert
-check_result('rec7', 'record8', 'rec9');
-@r = splice(@a, 1, 2);               # delete more than one
-check_result('record9','rec10');
-
-# (23-32) splicing at the end
-@r = splice(@a, 3, 0, "rec4");
-check_result();
-@r = splice(@a, 3, 1, "rec5");       # same length
-check_result('rec4');
-@r = splice(@a, 3, 1, "record5");    # longer
-check_result('rec5');
-
-@r = splice(@a, 3, 1, "r5");         # shorter
-check_result('record5');
-@r = splice(@a, 3, 1);               # removal
-check_result('r5');
-@r = splice(@a, 3, 0);               # no-op
-check_result();
-@r = splice(@a, 3, 0, 'r7', 'rec8'); # insert more than one
-check_result();
-@r = splice(@a, 3, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_result('r7', 'rec8');
-
-@r = splice(@a, 3, 3, 'record9', 'rec10'); # delete more than insert
-check_result('rec7', 'record8', 'rec9');
-@r = splice(@a, 3, 2);               # delete more than one
-check_result('record9', 'rec10');
-
-# (33-42) splicing with negative subscript
-@r = splice(@a, -1, 0, "rec4");
-check_result();
-@r = splice(@a, -1, 1, "rec5");       # same length
-check_result('rec2');
-@r = splice(@a, -1, 1, "record5");    # longer
-check_result("rec5");
-
-@r = splice(@a, -1, 1, "r5");         # shorter
-check_result("record5");
-@r = splice(@a, -1, 1);               # removal
-check_result("r5");
-@r = splice(@a, -1, 0);               # no-op  
-check_result();
-@r = splice(@a, -1, 0, 'r7', 'rec8'); # insert more than one
-check_result();
-@r = splice(@a, -1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_result('rec4');
-
-@r = splice(@a, -3, 3, 'record9', 'rec10'); # delete more than insert
-check_result('rec7', 'record8', 'rec9');
-@r = splice(@a, -4, 3);               # delete more than one
-check_result('r7', 'rec8', 'record9');
-
-# (43) scrub it all out
-@r = splice(@a, 0, 3);
-check_result('rec0', 'rec1', 'rec10');
-
-# (44) put some back in
-@r = splice(@a, 0, 0, "rec0", "rec1");
-check_result();
-
-# (45) what if we remove too many records?
-@r = splice(@a, 0, 17);
-check_result('rec0', 'rec1');
-
-# (46-48) Now check the scalar context return
-splice(@a, 0, 0, qw(I like pie));
-my $r;
-$r = splice(@a, 0, 0);
-print !defined($r) ? "ok $N\n" : "not ok $N \# return should have been undef, was <$r>\n";
-$N++;
-
-$r = splice(@a, 2, 1);
-print $r eq "pie$:" ? "ok $N\n" : "not ok $N \# return should have been 'pie\\n', was <$r>\n";
-$N++;
-
-$r = splice(@a, 0, 2);
-print $r eq "like$:" ? "ok $N\n" : "not ok $N \# return should have been 'like\\n', was <$r>\n";
-$N++;
-
-# (49-50) Test default arguments
-splice @a, 0, 0, (0..11);
-@r = splice @a, 4;
-check_result(4..11);
-@r = splice @a;
-check_result(0..3);
-
-# (51-56) splice with negative length was treated wrong
-# 20020402 Reported by Juerd Waalboer
-@a = (0..8) ;
-@r = splice @a, 0, -3;
-check_result(0..5);
-@a = (0..8) ;
-@r = splice @a, 1, -3;
-check_result(1..5);
-@a = (0..8) ;
-@r = splice @a, 7, -3;
-check_result();
-@a = (0..2) ;
-@r = splice @a, 0, -3;
-check_result();
-@a = (0..2) ;
-@r = splice @a, 1, -3;
-check_result();
-@a = (0..2) ;
-@r = splice @a, 7, -3;
-check_result();
-
-sub init_file {
-  my $data = shift;
-  open F, "> $file" or die $!;
-  binmode F;
-  print F $data;
-  close F;
-}
-
-# actual results are in @r.
-# expected results are in @_
-sub check_result {
-  my @x = @_;
-  s/$:$// for @r;
-  my $good = 1;
-  $good = 0 unless @r == @x;
-  for my $i (0 .. $#r) {
-    $good = 0 unless $r[$i] eq $x[$i];
-  }
-  print $good ? "ok $N\n" : "not ok $N \# was (@r); should be (@x)\n";
-  $N++;
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/08_ro.t b/ext/Tie-File/t/08_ro.t
deleted file mode 100644
index 5fd8933bf8..0000000000
--- a/ext/Tie-File/t/08_ro.t
+++ /dev/null
@@ -1,86 +0,0 @@
-#!/usr/bin/perl
-#
-# Make sure it works to open the file in read-only mode
-#
-
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-
-print "1..13\n";
-
-my $N = 1;
-use Tie::File;
-use Fcntl 'O_RDONLY';
-print "ok $N\n"; $N++;
-
-my @items = qw(Gold Frankincense Myrrh Ivory Apes Peacocks);
-init_file(join $:, @items, '');
-
-my $o = tie @a, 'Tie::File', $file, mode => O_RDONLY, autochomp => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-$#a == $#items ? print "ok $N\n" : print "not ok $N\n";
-$N++;
-
-for my $i (0..$#items) {
-  ("$items[$i]$:" eq $a[$i]) ? print "ok $N\n" : print "not ok $N\n";
-  $N++;
-}
-
-sub init_file {
-  my $data = shift;
-  open F, "> $file" or die $!;
-  binmode F;
-  print F $data;
-  close F;
-}
-
-undef $o; untie @a;
-my $badrec = "Malformed";
-# (10-13) When a record lacks the record seprator, we sneakily try
-# to fix it.  How does that work when the file is read-only?
-if (setup_badly_terminated_file(4)) {
-  my $good = 1;
-  my $warn;
-  local $SIG{__WARN__} = sub { $good = 0; ctrlfix($warn = shift); };
-  local $^W = 1;
-  my $o = tie @a, 'Tie::File', $file, mode => O_RDONLY, autochomp => 0
-    or die "Couldn't tie $file: $!";
-
-  print $a[0] eq "Malformed$:" ? "ok $N\n" : "not ok $N\n";  $N++;
-  print $good ? "ok $N\n" : "not ok $N # $warn\n";  $good = 1; $N++;
-  print $a[0] eq "Malformed$:" ? "ok $N\n" : "not ok $N\n";  $N++;
-  print $good ? "ok $N\n" : "not ok $N # $warn\n";  $good = 1; $N++;
-}
-
-sub setup_badly_terminated_file {
-  my $NTESTS = shift;
-  open F, "> $file" or die "Couldn't open $file: $!";
-  binmode F;
-  print F $badrec;
-  close F;
-  unless (-s $file == length $badrec) {
-    for (1 .. $NTESTS) {
-      print "ok $N \# skipped - can't create improperly terminated file\n";
-      $N++;
-    }
-    return;
-  }
-  return 1;
-}
-
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/09_gen_rs.t b/ext/Tie-File/t/09_gen_rs.t
deleted file mode 100644
index e590210335..0000000000
--- a/ext/Tie-File/t/09_gen_rs.t
+++ /dev/null
@@ -1,225 +0,0 @@
-#!/usr/bin/perl
-
-my $file = "tf$$.txt";
-
-print "1..59\n";
-
-use Fcntl 'O_RDONLY';
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-$RECSEP = 'blah';
-my $o = tie @a, 'Tie::File', $file, 
-    recsep => $RECSEP, autochomp => 0, autodefer => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-
-# 3-4 create
-$a[0] = 'rec0';
-check_contents("rec0");
-
-# 5-8 append
-$a[1] = 'rec1';
-check_contents("rec0", "rec1");
-$a[2] = 'rec2';
-check_contents("rec0", "rec1", "rec2");
-
-# 9-14 same-length alterations
-$a[0] = 'new0';
-check_contents("new0", "rec1", "rec2");
-$a[1] = 'new1';
-check_contents("new0", "new1", "rec2");
-$a[2] = 'new2';
-check_contents("new0", "new1", "new2");
-
-# 15-24 lengthening alterations
-$a[0] = 'long0';
-check_contents("long0", "new1", "new2");
-$a[1] = 'long1';
-check_contents("long0", "long1", "new2");
-$a[2] = 'long2';
-check_contents("long0", "long1", "long2");
-$a[1] = 'longer1';
-check_contents("long0", "longer1", "long2");
-$a[0] = 'longer0';
-check_contents("longer0", "longer1", "long2");
-
-# 25-34 shortening alterations, including truncation
-$a[0] = 'short0';
-check_contents("short0", "longer1", "long2");
-$a[1] = 'short1';
-check_contents("short0", "short1", "long2");
-$a[2] = 'short2';
-check_contents("short0", "short1", "short2");
-$a[1] = 'sh1';
-check_contents("short0", "sh1", "short2");
-$a[0] = 'sh0';
-check_contents("sh0", "sh1", "short2");
-
-# (35-38) file with holes
-$a[4] = 'rec4';
-check_contents("sh0", "sh1", "short2", "", "rec4");
-$a[3] = 'rec3';
-check_contents("sh0", "sh1", "short2", "rec3", "rec4");
-
-# (39-40) zero out file
-@a = ();
-check_contents();
-
-# (41-42) insert into the middle of an empty file
-$a[3] = "rec3";
-check_contents("", "", "", "rec3");
-
-# (43-47) 20020326 You thought there would be a bug in STORE where if
-# a cached record was false, STORE wouldn't see it at all.  Yup, there is,
-# and adding the appropriate defined() test fixes the problem.
-undef $o;  untie @a;  1 while unlink $file;
-$RECSEP = '0';
-$o = tie @a, 'Tie::File', $file, 
-    recsep => $RECSEP, autochomp => 0, autodefer => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-$#a = 2;
-my $z = $a[1];                  # caches "0"
-$a[2] = "oops";
-check_contents("", "", "oops");
-$a[1] = "bah";
-check_contents("", "bah", "oops");
-undef $o; untie @a;
-
-# (48-56) 20020331 Make sure we correctly handle the case where the final
-# record of the file is not properly terminated, Through version 0.90,
-# we would mangle the file.
-my $badrec = "Malformed";
-$: = $RECSEP = Tie::File::_default_recsep();
-# (48-50)
-if (setup_badly_terminated_file(3)) {
-  $o = tie @a, 'Tie::File', $file,
-    recsep => $RECSEP, autochomp => 0, autodefer => 0
-    or die "Couldn't tie file: $!";
-  my $z = $a[0];
-  print $z eq "$badrec$:" ? "ok $N\n" : 
-                        "not ok $N \# got $z, expected $badrec\n";
-  $N++;
-  push @a, "next";
-  check_contents($badrec, "next");
-}
-# (51-52)
-if (setup_badly_terminated_file(2)) {
-  $o = tie @a, 'Tie::File', $file,
-    recsep => $RECSEP, autochomp => 0, autodefer => 0
-    or die "Couldn't tie file: $!";
-  splice @a, 1, 0, "x", "y";
-  check_contents($badrec, "x", "y");
-}
-# (53-56)
-if (setup_badly_terminated_file(4)) {
-  $o = tie @a, 'Tie::File', $file,
-    recsep => $RECSEP, autochomp => 0, autodefer => 0
-    or die "Couldn't tie file: $!";
-  my @r = splice @a, 0, 1, "x", "y";
-  my $n = @r;
-  print $n == 1 ? "ok $N\n" : "not ok $N \# expected 1 elt, got $n\n";
-  $N++;
-  print $r[0] eq "$badrec$:" ? "ok $N\n"
-    : "not ok $N \# expected <$badrec>, got <$r[0]>\n";
-  $N++;
-  check_contents("x", "y");
-}
-
-# (57-58) 20020402 The modification would have failed if $\ were set wrong.
-# I hate $\.
-if (setup_badly_terminated_file(2)) {
-  $o = tie @a, 'Tie::File', $file,
-    recsep => $RECSEP, autochomp => 0, autodefer => 0
-    or die "Couldn't tie file: $!";
-  { local $\ = "I hate \$\\.";
-    my $z = $a[0];
-  }
-  check_contents($badrec);
-}
-
-# (59) 20030527 Tom Christiansen pointed out that FETCH returns the wrong
-# data on the final record of an unterminated file if the file is opened
-# in read-only mode.  Note that the $#a is necessary here.
-# There's special-case code to fix the final record when it is read normally.
-# But the $#a forces it to be read from the cache, which skips the
-# termination.
-$badrec = "world${RECSEP}hello";
-if (setup_badly_terminated_file(1)) {
-  tie(@a, "Tie::File", $file, mode => O_RDONLY, recsep => $RECSEP)
-      or die "Couldn't tie file: $!";
-  my $z = $#a;
-  $z = $a[1];
-  print $z eq "hello" ? "ok $N\n" : 
-      "not ok $N \# got $z, expected hello\n";
-  $N++;
-}
-
-sub setup_badly_terminated_file {
-  my $NTESTS = shift;
-  open F, "> $file" or die "Couldn't open $file: $!";
-  binmode F;
-  print F $badrec;
-  close F;
-  unless (-s $file == length $badrec) {
-    for (1 .. $NTESTS) {
-      print "ok $N \# skipped - can't create improperly terminated file\n";
-      $N++;
-    }
-    return;
-  }
-  return 1;
-}
-
-
-use POSIX 'SEEK_SET';
-sub check_contents {
-  my @c = @_;
-  my $x = join $RECSEP, @c, '';
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-  my $a;
-  { local $/; $a = <FH> }
-
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    my $msg = "# expected <$x>, got <$a>";
-    ctrlfix($msg);
-    print "not ok $N $msg\n";
-  }
-  $N++;
-
-  # now check FETCH:
-  my $good = 1;
-  for (0.. $#c) {
-    unless ($a[$_] eq "$c[$_]$RECSEP") {
-      $msg = "expected $c[$_]$RECSEP, got $a[$_]";
-      ctrlfix($msg);
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N # fetch $msg\n";
-  $N++;
-}
-
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/10_splice_rs.t b/ext/Tie-File/t/10_splice_rs.t
deleted file mode 100644
index 50b8b0a7ee..0000000000
--- a/ext/Tie-File/t/10_splice_rs.t
+++ /dev/null
@@ -1,215 +0,0 @@
-#!/usr/bin/perl
-#
-# Check SPLICE function's effect on the file
-# (07_rv_splice.t checks its return value)
-#
-# Each call to 'check_contents' actually performs two tests.
-# First, it calls the tied object's own 'check_integrity' method,
-# which makes sure that the contents of the read cache and offset tables
-# accurately reflect the contents of the file.  
-# Then, it checks the actual contents of the file against the expected
-# contents.
-
-use POSIX 'SEEK_SET';
-
-my $file = "tf$$.txt";
-my $data = "rec0blahrec1blahrec2blah";
-
-print "1..101\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;  # partial credit just for showing up
-
-init_file($data);
-
-my $o = tie @a, 'Tie::File', $file, recsep => 'blah';
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-my $n;
-
-# (3-22) splicing at the beginning
-splice(@a, 0, 0, "rec4");
-check_contents("rec4blah$data");
-splice(@a, 0, 1, "rec5");       # same length
-check_contents("rec5blah$data");
-splice(@a, 0, 1, "record5");    # longer
-check_contents("record5blah$data");
-
-splice(@a, 0, 1, "r5");         # shorter
-check_contents("r5blah$data");
-splice(@a, 0, 1);               # removal
-check_contents("$data");
-splice(@a, 0, 0);               # no-op
-check_contents("$data");
-splice(@a, 0, 0, 'r7', 'rec8'); # insert more than one
-check_contents("r7blahrec8blah$data");
-splice(@a, 0, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_contents("rec7blahrecord8blahrec9blah$data");
-
-splice(@a, 0, 3, 'record9', 'rec10'); # delete more than insert
-check_contents("record9blahrec10blah$data");
-splice(@a, 0, 2);               # delete more than one
-check_contents("$data");
-
-
-# (23-42) splicing in the middle
-splice(@a, 1, 0, "rec4");
-check_contents("rec0blahrec4blahrec1blahrec2blah");
-splice(@a, 1, 1, "rec5");       # same length
-check_contents("rec0blahrec5blahrec1blahrec2blah");
-splice(@a, 1, 1, "record5");    # longer
-check_contents("rec0blahrecord5blahrec1blahrec2blah");
-
-splice(@a, 1, 1, "r5");         # shorter
-check_contents("rec0blahr5blahrec1blahrec2blah");
-splice(@a, 1, 1);               # removal
-check_contents("$data");
-splice(@a, 1, 0);               # no-op
-check_contents("$data");
-splice(@a, 1, 0, 'r7', 'rec8'); # insert more than one
-check_contents("rec0blahr7blahrec8blahrec1blahrec2blah");
-splice(@a, 1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_contents("rec0blahrec7blahrecord8blahrec9blahrec1blahrec2blah");
-
-splice(@a, 1, 3, 'record9', 'rec10'); # delete more than insert
-check_contents("rec0blahrecord9blahrec10blahrec1blahrec2blah");
-splice(@a, 1, 2);               # delete more than one
-check_contents("$data");
-
-# (43-62) splicing at the end
-splice(@a, 3, 0, "rec4");
-check_contents("$ {data}rec4blah");
-splice(@a, 3, 1, "rec5");       # same length
-check_contents("$ {data}rec5blah");
-splice(@a, 3, 1, "record5");    # longer
-check_contents("$ {data}record5blah");
-
-splice(@a, 3, 1, "r5");         # shorter
-check_contents("$ {data}r5blah");
-splice(@a, 3, 1);               # removal
-check_contents("$data");
-splice(@a, 3, 0);               # no-op
-check_contents("$data");
-splice(@a, 3, 0, 'r7', 'rec8'); # insert more than one
-check_contents("$ {data}r7blahrec8blah");
-splice(@a, 3, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_contents("$ {data}rec7blahrecord8blahrec9blah");
-
-splice(@a, 3, 3, 'record9', 'rec10'); # delete more than insert
-check_contents("$ {data}record9blahrec10blah");
-splice(@a, 3, 2);               # delete more than one
-check_contents("$data");
-
-# (63-82) splicing with negative subscript
-splice(@a, -1, 0, "rec4");
-check_contents("rec0blahrec1blahrec4blahrec2blah");
-splice(@a, -1, 1, "rec5");       # same length
-check_contents("rec0blahrec1blahrec4blahrec5blah");
-splice(@a, -1, 1, "record5");    # longer
-check_contents("rec0blahrec1blahrec4blahrecord5blah");
-
-splice(@a, -1, 1, "r5");         # shorter
-check_contents("rec0blahrec1blahrec4blahr5blah");
-splice(@a, -1, 1);               # removal
-check_contents("rec0blahrec1blahrec4blah");
-splice(@a, -1, 0);               # no-op  
-check_contents("rec0blahrec1blahrec4blah");
-splice(@a, -1, 0, 'r7', 'rec8'); # insert more than one
-check_contents("rec0blahrec1blahr7blahrec8blahrec4blah");
-splice(@a, -1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_contents("rec0blahrec1blahr7blahrec8blahrec7blahrecord8blahrec9blah");
-
-splice(@a, -3, 3, 'record9', 'rec10'); # delete more than insert
-check_contents("rec0blahrec1blahr7blahrec8blahrecord9blahrec10blah");
-splice(@a, -4, 3);               # delete more than one
-check_contents("rec0blahrec1blahrec10blah");
-
-# (83-84) scrub it all out
-splice(@a, 0, 3);
-check_contents("");
-
-# (85-86) put some back in
-splice(@a, 0, 0, "rec0", "rec1");
-check_contents("rec0blahrec1blah");
-
-# (87-88) what if we remove too many records?
-splice(@a, 0, 17);
-check_contents("");
-
-# (89-92) In the past, splicing past the end was not correctly detected
-# (0.14)
-splice(@a, 89, 3);
-check_contents("");
-splice(@a, @a, 3);
-check_contents("");
-
-# (93-96) Also we did not emulate splice's freaky behavior when inserting
-# past the end of the array (1.14)
-splice(@a, 89, 0, "I", "like", "pie");
-check_contents("Iblahlikeblahpieblah");
-splice(@a, 89, 0, "pie pie pie");
-check_contents("Iblahlikeblahpieblahpie pie pieblah");
-
-# (97) Splicing with too large a negative number should be fatal
-# This test ignored because it causes 5.6.1 and 5.7.3 to dump core
-# It also garbles the stack under 5.005_03 (20020401)
-# NOT MY FAULT
-if ($] > 5.007003) {
-  eval { splice(@a, -7, 0) };
-  print $@ =~ /^Modification of non-creatable array value attempted, subscript -7/
-      ? "ok $N\n" : "not ok $N \# \$\@ was '$@'\n";
-} else { 
-  print "ok $N \# skipped (versions through 5.7.3 dump core here.)\n";
-}
-$N++;
-
-# (98-101) Test default arguments
-splice @a, 0, 0, (0..11);
-splice @a, 4;
-check_contents("0blah1blah2blah3blah");
-splice @a;
-check_contents("");
-
-
-sub init_file {
-  my $data = shift;
-  open F, "> $file" or die $!;
-  binmode F;
-  print F $data;
-  close F;
-}
-
-sub check_contents {
-  my $x = shift;
-  my $integrity = $o->_check_integrity($file, $ENV{INTEGRITY});
-  print $integrity ? "ok $N\n" : "not ok $N\n";
-  $N++;
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix(my $msg = "# expected <$x>, got <$a>");
-    print "not ok $N\n$msg\n";
-  }
-  $N++;
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/11_rv_splice_rs.t b/ext/Tie-File/t/11_rv_splice_rs.t
deleted file mode 100644
index ae1053802a..0000000000
--- a/ext/Tie-File/t/11_rv_splice_rs.t
+++ /dev/null
@@ -1,182 +0,0 @@
-#!/usr/bin/perl
-#
-# Check SPLICE function's return value
-# (04_splice.t checks its effect on the file)
-#
-
-my $file = "tf$$.txt";
-my $data = "rec0blahrec1blahrec2blah";
-
-print "1..50\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;  # partial credit just for showing up
-
-init_file($data);
-
-my $o = tie @a, 'Tie::File', $file, autochomp => 0, recsep => 'blah';
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-my $n;
-
-# (3-12) splicing at the beginning
-@r = splice(@a, 0, 0, "rec4");
-check_result();
-@r = splice(@a, 0, 1, "rec5");       # same length
-check_result("rec4");
-@r = splice(@a, 0, 1, "record5");    # longer
-check_result("rec5");
-
-@r = splice(@a, 0, 1, "r5");         # shorter
-check_result("record5");
-@r = splice(@a, 0, 1);               # removal
-check_result("r5");
-@r = splice(@a, 0, 0);               # no-op
-check_result();
-@r = splice(@a, 0, 0, 'r7', 'rec8'); # insert more than one
-check_result();
-@r = splice(@a, 0, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_result('r7', 'rec8');
-
-@r = splice(@a, 0, 3, 'record9', 'rec10'); # delete more than insert
-check_result('rec7', 'record8', 'rec9');
-@r = splice(@a, 0, 2);               # delete more than one
-check_result('record9', 'rec10');
-
-
-# (13-22) splicing in the middle
-@r = splice(@a, 1, 0, "rec4");
-check_result();
-@r = splice(@a, 1, 1, "rec5");       # same length
-check_result('rec4');
-@r = splice(@a, 1, 1, "record5");    # longer
-check_result('rec5');
-
-@r = splice(@a, 1, 1, "r5");         # shorter
-check_result("record5");
-@r = splice(@a, 1, 1);               # removal
-check_result("r5");
-@r = splice(@a, 1, 0);               # no-op
-check_result();
-@r = splice(@a, 1, 0, 'r7', 'rec8'); # insert more than one
-check_result();
-@r = splice(@a, 1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_result('r7', 'rec8');
-
-@r = splice(@a, 1, 3, 'record9', 'rec10'); # delete more than insert
-check_result('rec7', 'record8', 'rec9');
-@r = splice(@a, 1, 2);               # delete more than one
-check_result('record9','rec10');
-
-# (23-32) splicing at the end
-@r = splice(@a, 3, 0, "rec4");
-check_result();
-@r = splice(@a, 3, 1, "rec5");       # same length
-check_result('rec4');
-@r = splice(@a, 3, 1, "record5");    # longer
-check_result('rec5');
-
-@r = splice(@a, 3, 1, "r5");         # shorter
-check_result('record5');
-@r = splice(@a, 3, 1);               # removal
-check_result('r5');
-@r = splice(@a, 3, 0);               # no-op
-check_result();
-@r = splice(@a, 3, 0, 'r7', 'rec8'); # insert more than one
-check_result();
-@r = splice(@a, 3, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_result('r7', 'rec8');
-
-@r = splice(@a, 3, 3, 'record9', 'rec10'); # delete more than insert
-check_result('rec7', 'record8', 'rec9');
-@r = splice(@a, 3, 2);               # delete more than one
-check_result('record9', 'rec10');
-
-# (33-42) splicing with negative subscript
-@r = splice(@a, -1, 0, "rec4");
-check_result();
-@r = splice(@a, -1, 1, "rec5");       # same length
-check_result('rec2');
-@r = splice(@a, -1, 1, "record5");    # longer
-check_result("rec5");
-
-@r = splice(@a, -1, 1, "r5");         # shorter
-check_result("record5");
-@r = splice(@a, -1, 1);               # removal
-check_result("r5");
-@r = splice(@a, -1, 0);               # no-op  
-check_result();
-@r = splice(@a, -1, 0, 'r7', 'rec8'); # insert more than one
-check_result();
-@r = splice(@a, -1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_result('rec4');
-
-@r = splice(@a, -3, 3, 'record9', 'rec10'); # delete more than insert
-check_result('rec7', 'record8', 'rec9');
-@r = splice(@a, -4, 3);               # delete more than one
-check_result('r7', 'rec8', 'record9');
-
-# (43) scrub it all out
-@r = splice(@a, 0, 3);
-check_result('rec0', 'rec1', 'rec10');
-
-# (44) put some back in
-@r = splice(@a, 0, 0, "rec0", "rec1");
-check_result();
-
-# (45) what if we remove too many records?
-@r = splice(@a, 0, 17);
-check_result('rec0', 'rec1');
-
-# (46-48) Now check the scalar context return
-splice(@a, 0, 0, qw(I like pie));
-my $r;
-$r = splice(@a, 0, 0);
-print !defined($r) ? "ok $N\n" : "not ok $N \# return should have been undef\n";
-$N++;
-
-$r = splice(@a, 2, 1);
-print $r eq "pieblah" ? "ok $N\n" : "not ok $N \# return should have been 'pie'\n";
-$N++;
-
-$r = splice(@a, 0, 2);
-print $r eq "likeblah" ? "ok $N\n" : "not ok $N \# return should have been 'like'\n";
-$N++;
-
-# (49-50) Test default arguments
-splice @a, 0, 0, (0..11);
-@r = splice @a, 4;
-check_result(4..11);
-@r = splice @a;
-check_result(0..3);
-
-sub init_file {
-  my $data = shift;
-  open F, "> $file" or die $!;
-  binmode F;
-  print F $data;
-  close F;
-}
-
-# actual results are in @r.
-# expected results are in @_
-sub check_result {
-  my @x = @_;
-  s/blah$// for @r;
-  my $good = 1;
-  $good = 0 unless @r == @x;
-  for my $i (0 .. $#r) {
-    $good = 0 unless $r[$i] eq $x[$i];
-  }
-  print $good ? "ok $N\n" : "not ok $N \# was (@r); should be (@x)\n";
-  $N++;
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/12_longfetch_rs.t b/ext/Tie-File/t/12_longfetch_rs.t
deleted file mode 100644
index 6f1905d6af..0000000000
--- a/ext/Tie-File/t/12_longfetch_rs.t
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/usr/bin/perl
-#
-# Make sure we can fetch a record in the middle of the file
-# before we've ever looked at any records before it
-#
-# (tests _fill_offsets_to() )
-#
-
-my $file = "tf$$.txt";
-my $data = "rec0blahrec1blahrec2blah";
-
-print "1..5\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-open F, "> $file" or die $!;
-binmode F;
-print F $data;
-close F;
-
-
-my $o = tie @a, 'Tie::File', $file, autochomp => 0, recsep => 'blah';
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-my $n;
-
-# 3-5
-for (2, 1, 0) {
-  print $a[$_] eq "rec${_}blah" ? "ok $N\n" : "not ok $N # rec=$a[$_] ?\n";
-  $N++;
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/13_size_rs.t b/ext/Tie-File/t/13_size_rs.t
deleted file mode 100644
index a2a8d53bdd..0000000000
--- a/ext/Tie-File/t/13_size_rs.t
+++ /dev/null
@@ -1,95 +0,0 @@
-#!/usr/bin/perl
-#
-# Check FETCHSIZE and SETSIZE functions
-# PUSH POP SHIFT UNSHIFT
-#
-
-use POSIX 'SEEK_SET';
-
-my $file = "tf$$.txt";
-my $data = "rec0blahrec1blahrec2blah";
-my ($o, $n);
-
-print "1..10\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-# 2-3 FETCHSIZE 0-length file
-open F, "> $file" or die $!;
-close F;
-$o = tie @a, 'Tie::File', $file, recsep => 'blah';
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-$n = @a;
-print $n == 0 ? "ok $N\n" : "not ok $N # $n, s/b 0\n";
-$N++;
-
-# Reset everything
-undef $o;
-untie @a;
-
-# 4-5 FETCHSIZE positive-length file
-open F, "> $file" or die $!;
-print F $data;
-close F;
-$o = tie @a, 'Tie::File', $file, recsep => 'blah';
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-$n = @a;
-print $n == 3 ? "ok $N\n" : "not ok $N # $n, s/b 0\n";
-$N++;
-
-# STORESIZE
-# 6 Make it longer:
-$#a = 4;
-check_contents("${data}blahblah");
-
-# 7 Make it longer again:
-$#a = 6;
-check_contents("${data}blahblahblahblah");
-
-# 8 Make it shorter:
-$#a = 4;
-check_contents("${data}blahblah");
-
-# 9 Make it shorter again:
-$#a = 2;
-check_contents($data);
-
-# 10 Get rid of it completely:
-$#a = -1;
-check_contents('');
-
-
-sub check_contents {
-  my $x = shift;
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix(my $msg = "# expected <$x>, got <$a>");
-    print "not ok $N\n$msg\n";
-  }
-  $N++;
-}
-
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/14_lock.t b/ext/Tie-File/t/14_lock.t
deleted file mode 100644
index cab48125b0..0000000000
--- a/ext/Tie-File/t/14_lock.t
+++ /dev/null
@@ -1,50 +0,0 @@
-#!/usr/bin/perl
-#
-# Check flock() feature
-#
-# This isn't a real test; it just checks to make sure we can call the method.
-# It doesn't even check to make sure that the default behavior
-# (LOCK_EX) is occurring.  This is because I don't know how to write a good
-# portable test for flocking.  I checked the Perl core distribution,
-# and found that Perl doesn't test flock either!
-
-BEGIN {
-  eval { flock STDOUT, 0 };
-  if ($@ && $@ =~ /unimplemented/) {
-    print "1..0\n";
-    exit;
-  }
-}
-
-use Fcntl ':flock';             # This works at least back to 5.004_04
-
-my $file = "tf$$.txt";
-my ($o, $n);
-my @a;
-
-print "1..4\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-# 2-4  Who the heck knows?
-open F, "> $file" or die $!;
-close F;
-$o = tie @a, 'Tie::File', $file, recsep => 'blah';
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-print $o->flock() ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-print $o->flock(LOCK_UN) ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/15_pushpop.t b/ext/Tie-File/t/15_pushpop.t
deleted file mode 100644
index 4b6d1bc959..0000000000
--- a/ext/Tie-File/t/15_pushpop.t
+++ /dev/null
@@ -1,135 +0,0 @@
-#!/usr/bin/perl
-#
-# Check PUSH, POP, SHIFT, and UNSHIFT 
-#
-# Each call to 'check_contents' actually performs two tests.
-# First, it calls the tied object's own 'check_integrity' method,
-# which makes sure that the contents of the read cache and offset tables
-# accurately reflect the contents of the file.  
-# Then, it checks the actual contents of the file against the expected
-# contents.
-
-use POSIX 'SEEK_SET';
-
-my $file = "tf$$.txt";
-1 while unlink $file;
-$: = Tie::File::_default_recsep();
-my $data = "rec0$:rec1$:rec2$:";
-
-print "1..38\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;  # partial credit just for showing up
-
-my $o = tie @a, 'Tie::File', $file, autochomp => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-my ($n, @r);
-
-
-# (3-11) PUSH tests
-$n = push @a, "rec0", "rec1", "rec2";
-check_contents($data);
-print $n == 3 ? "ok $N\n" : "not ok $N # size is $n, should be 3\n";
-$N++;
-
-$n = push @a, "rec3", "rec4$:";
-check_contents("$ {data}rec3$:rec4$:");
-print $n == 5 ? "ok $N\n" : "not ok $N # size is $n, should be 5\n";
-$N++;
-
-# Trivial push
-$n = push @a, ();
-check_contents("$ {data}rec3$:rec4$:");
-print $n == 5 ? "ok $N\n" : "not ok $N # size is $n, should be 5\n";
-$N++;
-
-# (12-20) POP tests
-$n = pop @a;
-check_contents("$ {data}rec3$:");
-print $n eq "rec4$:" ? "ok $N\n" : "not ok $N # last rec is $n, should be rec4\n";
-$N++;
-
-# Presumably we have already tested this to death
-splice(@a, 1, 3);
-$n = pop @a;
-check_contents("");
-print $n eq "rec0$:" ? "ok $N\n" : "not ok $N # last rec is $n, should be rec0\n";
-$N++;
-
-$n = pop @a;
-check_contents("");
-print ! defined $n ? "ok $N\n" : "not ok $N # last rec should be undef, is $n\n";
-$N++;
-
-
-# (21-29) UNSHIFT tests
-$n = unshift @a, "rec0", "rec1", "rec2";
-check_contents($data);
-print $n == 3 ? "ok $N\n" : "not ok $N # size is $n, should be 3\n";
-$N++;
-
-$n = unshift @a, "rec3", "rec4$:";
-check_contents("rec3$:rec4$:$data");
-print $n == 5 ? "ok $N\n" : "not ok $N # size is $n, should be 5\n";
-$N++;
-
-# Trivial unshift
-$n = unshift @a, ();
-check_contents("rec3$:rec4$:$data");
-print $n == 5 ? "ok $N\n" : "not ok $N # size is $n, should be 5\n";
-$N++;
-
-# (30-38) SHIFT tests
-$n = shift @a;
-check_contents("rec4$:$data");
-print $n eq "rec3$:" ? "ok $N\n" : "not ok $N # last rec is $n, should be rec3\n";
-$N++;
-
-# Presumably we have already tested this to death
-splice(@a, 1, 3);
-$n = shift @a;
-check_contents("");
-print $n eq "rec4$:" ? "ok $N\n" : "not ok $N # last rec is $n, should be rec4\n";
-$N++;
-
-$n = shift @a;
-check_contents("");
-print ! defined $n ? "ok $N\n" : "not ok $N # last rec should be undef, is $n\n";
-$N++;
-
-
-sub check_contents {
-  my $x = shift;
-  my $integrity = $o->_check_integrity($file, $ENV{INTEGRITY});
-  print $integrity ? "ok $N\n" : "not ok $N\n";
-  $N++;
-
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix(my $msg = "# expected <$x>, got <$a>");
-    print "not ok $N\n$msg\n";
-  }
-  $N++;
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/16_handle.t b/ext/Tie-File/t/16_handle.t
deleted file mode 100644
index f799496be1..0000000000
--- a/ext/Tie-File/t/16_handle.t
+++ /dev/null
@@ -1,160 +0,0 @@
-#!/usr/bin/perl
-#
-# Basic operation, initializing the object from an already-open handle
-# instead of from a filename
-
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-
-if ($^O =~ /vms/i) {
-  print "1..0\n";
-  exit;
-}
-
-print "1..39\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-use Fcntl 'O_CREAT', 'O_RDWR';
-sysopen F, $file, O_CREAT | O_RDWR 
-  or die "Couldn't create temp file $file: $!; aborting";
-binmode F;
-
-my $o = tie @a, 'Tie::File', \*F, autochomp => 0, autodefer => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# 3-4 create
-$a[0] = 'rec0';
-check_contents("rec0");
-
-# 5-8 append
-$a[1] = 'rec1';
-check_contents("rec0", "rec1");
-$a[2] = 'rec2';
-check_contents("rec0", "rec1", "rec2");
-
-# 9-14 same-length alterations
-$a[0] = 'new0';
-check_contents("new0", "rec1", "rec2");
-$a[1] = 'new1';
-check_contents("new0", "new1", "rec2");
-$a[2] = 'new2';
-check_contents("new0", "new1", "new2");
-
-# 15-24 lengthening alterations
-$a[0] = 'long0';
-check_contents("long0", "new1", "new2");
-$a[1] = 'long1';
-check_contents("long0", "long1", "new2");
-$a[2] = 'long2';
-check_contents("long0", "long1", "long2");
-$a[1] = 'longer1';
-check_contents("long0", "longer1", "long2");
-$a[0] = 'longer0';
-check_contents("longer0", "longer1", "long2");
-
-# 25-38 shortening alterations, including truncation
-$a[0] = 'short0';
-check_contents("short0", "longer1", "long2");
-$a[1] = 'short1';
-check_contents("short0", "short1", "long2");
-$a[2] = 'short2';
-check_contents("short0", "short1", "short2");
-$a[1] = 'sh1';
-check_contents("short0", "sh1", "short2");
-$a[0] = 'sh0';
-check_contents("sh0", "sh1", "short2");
-
-# file with holes
-$a[4] = 'rec4';
-check_contents("sh0", "sh1", "short2", "", "rec4");
-$a[3] = 'rec3';
-check_contents("sh0", "sh1", "short2", "rec3", "rec4");
-
-close F;
-undef $o;
-untie @a;
-
-# (39) Does it correctly detect a non-seekable handle?
-{  if ($^O =~ /^(MSWin32|dos|beos)$/) {
-     print "ok $N # skipped ($^O has broken pipe semantics)\n";
-     last;
-   }
-   if ($] < 5.006) {
-     print "ok $N # skipped - 5.005_03 panics after this test\n";
-     last;
-   }
-   my $pipe_succeeded = eval {pipe *R, *W};
-   if ($@) {
-     chomp $@;
-     print "ok $N # skipped (no pipes: $@)\n";
-     last;
-   } elsif (! $pipe_succeeded) {
-     print "ok $N # skipped (pipe call failed: $!)\n";
-     last;
-   }
-   close R;
-   $o = eval {tie @a, 'Tie::File', \*W};
-   if ($@) {
-     if ($@ =~ /filehandle does not appear to be seekable/) {
-       print "ok $N\n";
-     } else {
-       chomp $@;
-       print "not ok $N \# \$\@ is $@\n";
-     }
-   } else {
-       print "not ok $N \# passing pipe to TIEARRAY didn't abort program\n";
-   }
-   $N++;
-}
-
-use POSIX 'SEEK_SET';
-sub check_contents {
-  my @c = @_;
-  my $x = join $:, @c, '';
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-#  my $open = open FH, "< $file";
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix(my $msg = "# expected <$x>, got <$a>");
-    print "not ok $N\n$msg\n";
-  }
-  $N++;
-
-  # now check FETCH:
-  my $good = 1;
-  my $msg;
-  for (0.. $#c) {
-    unless ($a[$_] eq "$c[$_]$:") {
-      $msg = "expected $c[$_]$:, got $a[$_]";
-      ctrlfix($msg);
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N # $msg\n";
-  $N++;
-}
-
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
-
diff --git a/ext/Tie-File/t/17_misc_meth.t b/ext/Tie-File/t/17_misc_meth.t
deleted file mode 100644
index 020774bb91..0000000000
--- a/ext/Tie-File/t/17_misc_meth.t
+++ /dev/null
@@ -1,158 +0,0 @@
-#!/usr/bin/perl
-#
-# Check miscellaneous tied-array interface methods
-# EXTEND, CLEAR, DELETE, EXISTS
-#
-
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-1 while unlink $file;
-
-print "1..35\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-my $o = tie @a, 'Tie::File', $file, autodefer => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# (3-8) EXTEND
-$o->EXTEND(3);
-check_contents("$:$:$:");
-$o->EXTEND(4);
-check_contents("$:$:$:$:");
-$o->EXTEND(3);
-check_contents("$:$:$:$:");
-
-# (9-10) CLEAR
-@a = ();
-check_contents("");
-
-# (11-20) EXISTS
-if ($] >= 5.006) {
-  eval << 'TESTS';
-print !exists $a[0] ? "ok $N\n" : "not ok $N\n";
-$N++;
-$a[0] = "I like pie.";
-print exists $a[0] ? "ok $N\n" : "not ok $N\n";
-$N++;
-print !exists $a[1] ? "ok $N\n" : "not ok $N\n";
-$N++;
-$a[2] = "GIVE ME PIE";
-print exists $a[0] ? "ok $N\n" : "not ok $N\n";
-$N++;
-# exists $a[1] is not defined by this module under these circumstances
-print exists $a[1] ? "ok $N\n" : "ok $N\n";
-$N++;
-print exists $a[2] ? "ok $N\n" : "not ok $N\n";
-$N++;
-print exists $a[-1] ? "ok $N\n" : "not ok $N\n";
-$N++;
-print exists $a[-2] ? "ok $N\n" : "not ok $N\n";
-$N++;
-print exists $a[-3] ? "ok $N\n" : "not ok $N\n";
-$N++;
-print !exists $a[-4] ? "ok $N\n" : "not ok $N\n";
-$N++;
-TESTS
-  } else {                      # perl 5.005 doesn't have exists $array[1]
-    for (11..20) {
-      print "ok $_ \# skipped (no exists for arrays)\n";
-          $N++;
-    }
-  }
-
-my $del;
-
-# (21-35) DELETE
-if ($] >= 5.006) {
-  eval << 'TESTS';
-$del = delete $a[0];
-check_contents("$:$:GIVE ME PIE$:");
-# 20020317 Through 0.20, the 'delete' function returned the wrong values.
-expect($del, "I like pie.");
-$del = delete $a[2];
-check_contents("$:$:");
-expect($del, "GIVE ME PIE");
-$del = delete $a[0];
-check_contents("$:$:");
-expect($del, "");
-$del = delete $a[1];
-check_contents("$:");
-expect($del, "");
-
-# 20020317 Through 0.20, we had a bug where deleting an element past the 
-# end of the array would actually extend the array to that length.
-$del = delete $a[4];
-check_contents("$:");
-expect($del, undef);
-
-
-
-TESTS
-  } else {                      # perl 5.005 doesn't have delete $array[1]
-    for (21..35) {
-      print "ok $_ \# skipped (no delete for arrays)\n";
-          $N++;
-    }
-  }
-
-use POSIX 'SEEK_SET';
-sub check_contents {
-  my $x = shift;
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix(my $msg = "# expected <$x>, got <$a>");
-    print "not ok $N # $msg\n";
-  }
-  $N++;
-  print $o->_check_integrity($file, $ENV{INTEGRITY}) ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-sub expect {
-  if (@_ == 1) {
-    print $_[0] ? "ok $N\n" : "not ok $N\n";
-  } elsif (@_ == 2) {
-    my ($a, $x) = @_;
-    if    (! defined($a) && ! defined($x)) { print "ok $N\n" }
-    elsif (  defined($a) && ! defined($x)) { 
-      ctrlfix(my $msg = "expected UNDEF, got <$a>");
-      print "not ok $N \# $msg\n";
-    }
-    elsif (! defined($a) &&   defined($x)) { 
-      ctrlfix(my $msg = "expected <$x>, got UNDEF");
-      print "not ok $N \# $msg\n";
-    } elsif ($a eq $x) { print "ok $N\n" }
-    else {
-      ctrlfix(my $msg = "expected <$x>, got <$a>");
-      print "not ok $N \# $msg\n";
-    }
-  } else {
-    die "expect() got ", scalar(@_), " args, should have been 1 or 2";
-  }
-  $N++;
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
-
diff --git a/ext/Tie-File/t/18_rs_fixrec.t b/ext/Tie-File/t/18_rs_fixrec.t
deleted file mode 100644
index 3c2a807e64..0000000000
--- a/ext/Tie-File/t/18_rs_fixrec.t
+++ /dev/null
@@ -1,53 +0,0 @@
-#!/usr/bin/perl
-
-use POSIX 'SEEK_SET';
-my $file = "tf$$.txt";
-$/ = "blah";
-
-print "1..5\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-my $o = tie @a, 'Tie::File', $file, autodefer => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-$a[0] = 'rec0';
-check_contents("rec0blah");
-$a[1] = "rec1blah";
-check_contents("rec0blahrec1blah");
-$a[2] = "rec2blahblah";             # should we detect this?
-check_contents("rec0blahrec1blahrec2blahblah");
-
-sub check_contents {
-  my $x = shift;
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    my $msg = "not ok $N # expected <$x>, got <$a>";
-    ctrlfix($msg);
-    print "$msg\n";
-  }
-  $N++;
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/19_cache.t b/ext/Tie-File/t/19_cache.t
deleted file mode 100644
index 81c693263e..0000000000
--- a/ext/Tie-File/t/19_cache.t
+++ /dev/null
@@ -1,205 +0,0 @@
-#!/usr/bin/perl
-#
-# Tests for various caching errors
-#
-
-$|=1;
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-my $data = join $:, "rec0" .. "rec9", "";
-my $V = $ENV{INTEGRITY};        # Verbose integrity checking?
-
-print "1..55\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-open F, "> $file" or die $!;
-binmode F;
-print F $data;
-close F;
-
-my $o = tie @a, 'Tie::File', $file;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# (3) Through 0.18, this 'splice' call would corrupt the cache.
-my @z = @a;                     # force cache to contain all ten records
-splice @a, 0, 0, "x";
-print $o->_check_integrity($file, $V) ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# Here we redo *all* the splice tests, with populate()
-# calls before each one, to make sure that splice() does not botch the cache.
-
-# (4-14) splicing at the beginning
-check();
-splice(@a, 0, 0, "rec4");
-check();
-splice(@a, 0, 1, "rec5");       # same length
-check();
-splice(@a, 0, 1, "record5");    # longer
-check();
-splice(@a, 0, 1, "r5");         # shorter
-check();
-splice(@a, 0, 1);               # removal
-check();
-splice(@a, 0, 0);               # no-op
-check();
-
-splice(@a, 0, 0, 'r7', 'rec8'); # insert more than one
-check();
-splice(@a, 0, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check();
-splice(@a, 0, 3, 'record9', 'rec10'); # delete more than insert
-check();
-splice(@a, 0, 2);               # delete more than one
-check();
-
-
-# (15-24) splicing in the middle
-splice(@a, 1, 0, "rec4");
-check();
-splice(@a, 1, 1, "rec5");       # same length
-check();
-splice(@a, 1, 1, "record5");    # longer
-check();
-splice(@a, 1, 1, "r5");         # shorter
-check();
-splice(@a, 1, 1);               # removal
-check();
-splice(@a, 1, 0);               # no-op
-check();
-
-splice(@a, 1, 0, 'r7', 'rec8'); # insert more than one
-check();
-splice(@a, 1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check();
-splice(@a, 1, 3, 'record9', 'rec10'); # delete more than insert
-check();
-splice(@a, 1, 2);               # delete more than one
-check();
-
-# (25-34) splicing at the end
-splice(@a, 3, 0, "rec4");
-check();
-splice(@a, 3, 1, "rec5");       # same length
-check();
-splice(@a, 3, 1, "record5");    # longer
-check();
-splice(@a, 3, 1, "r5");         # shorter
-check();
-splice(@a, 3, 1);               # removal
-check();
-splice(@a, 3, 0);               # no-op
-check();
-
-splice(@a, 3, 0, 'r7', 'rec8'); # insert more than one
-check();
-splice(@a, 3, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check();
-splice(@a, 3, 3, 'record9', 'rec10'); # delete more than insert
-check();
-splice(@a, 3, 2);               # delete more than one
-check();
-
-# (35-44) splicing with negative subscript
-splice(@a, -1, 0, "rec4");
-check();
-splice(@a, -1, 1, "rec5");       # same length
-check();
-splice(@a, -1, 1, "record5");    # longer
-check();
-splice(@a, -1, 1, "r5");         # shorter
-check();
-splice(@a, -1, 1);               # removal
-check();
-splice(@a, -1, 0);               # no-op  
-check();
-
-splice(@a, -1, 0, 'r7', 'rec8'); # insert more than one
-check();
-splice(@a, -1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check();
-splice(@a, -3, 3, 'record9', 'rec10'); # delete more than insert
-check();
-splice(@a, -4, 3);               # delete more than one
-check();
-
-# (45) scrub it all out
-splice(@a, 0, 3);
-check();
-
-# (46) put some back in
-splice(@a, 0, 0, "rec0", "rec1");
-check();
-
-# (47) what if we remove too many records?
-splice(@a, 0, 17);
-check();
-
-# (48-49) In the past, splicing past the end was not correctly detected
-# (1.14)
-splice(@a, 89, 3);
-check();
-splice(@a, @a, 3);
-check();
-
-# (50-51) Also we did not emulate splice's freaky behavior when inserting
-# past the end of the array (1.14)
-splice(@a, 89, 0, "I", "like", "pie");
-check();
-splice(@a, 89, 0, "pie pie pie");
-check();
-
-# (52-54) Test default arguments
-splice @a, 0, 0, (0..11);
-check();
-splice @a, 4;
-check();
-splice @a;
-check();
-    
-# (55) This was broken on 20030507 when you moved the cache management
-# stuff out of _oadjust back into _splice without also putting it back 
-# into _store.
-@a = (0..11);
-check();
-
-sub init_file {
-  my $data = shift;
-  open F, "> $file" or die $!;
-  binmode F;
-  print F $data;
-  close F;
-}
-
-sub check {
-  my $integrity = $o->_check_integrity($file, $ENV{INTEGRITY});
-  print $integrity ? "ok $N\n" : "not ok $N\n";
-  $N++;
-  repopulate();
-}
-
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-sub repopulate {
-  $o->{cache}->empty;
-  my @z = @a;                   # refill the cache with correct data
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
-
-
diff --git a/ext/Tie-File/t/20_cache_full.t b/ext/Tie-File/t/20_cache_full.t
deleted file mode 100644
index 8b3bf0b2e0..0000000000
--- a/ext/Tie-File/t/20_cache_full.t
+++ /dev/null
@@ -1,228 +0,0 @@
-#!/usr/bin/perl
-#
-# Tests for various caching errors
-#
-
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-my $data = join $:, "record0" .. "record9", "";
-my $V = $ENV{INTEGRITY};        # Verbose integrity checking?
-
-print "1..111\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-open F, "> $file" or die $!;
-binmode F;
-print F $data;
-close F;
-
-# Limit cache size to 30 bytes 
-my $MAX = 30;
-#  -- that's enough space for 3 records, but not 4, on both \n and \r\n systems
-my $o = tie @a, 'Tie::File', $file, memory => $MAX, autodefer => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# (3-5) Let's see if data was properly expired from the cache
-my @z = @a;                     # force cache to contain all ten records
-# It should now contain only the *last* three records, 7, 8, and 9
-{
-  my $x = "7 8 9";
-  my $a = join " ", sort $o->{cache}->ckeys;
-  if ($a eq $x) { print "ok $N\n" }
-  else { print "not ok $N # cache keys were <$a>; expected <$x>\n" }
-  $N++;
-}
-check();
-
-# Here we redo *all* the splice tests, with populate()
-# calls before each one, to make sure that splice() does not botch the cache.
-
-# (6-25) splicing at the beginning
-splice(@a, 0, 0, "rec4");
-check();
-splice(@a, 0, 1, "rec5");       # same length
-check();
-splice(@a, 0, 1, "record5");    # longer
-check();
-splice(@a, 0, 1, "r5");         # shorter
-check();
-splice(@a, 0, 1);               # removal
-check();
-splice(@a, 0, 0);               # no-op
-check();
-
-splice(@a, 0, 0, 'r7', 'rec8'); # insert more than one
-check();
-splice(@a, 0, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check();
-splice(@a, 0, 3, 'record9', 'rec10'); # delete more than insert
-check();
-splice(@a, 0, 2);               # delete more than one
-check();
-
-
-# (26-45) splicing in the middle
-splice(@a, 1, 0, "rec4");
-check();
-splice(@a, 1, 1, "rec5");       # same length
-check();
-splice(@a, 1, 1, "record5");    # longer
-check();
-splice(@a, 1, 1, "r5");         # shorter
-check();
-splice(@a, 1, 1);               # removal
-check();
-splice(@a, 1, 0);               # no-op
-check();
-
-splice(@a, 1, 0, 'r7', 'rec8'); # insert more than one
-check();
-splice(@a, 1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check();
-splice(@a, 1, 3, 'record9', 'rec10'); # delete more than insert
-check();
-splice(@a, 1, 2);               # delete more than one
-check();
-
-# (46-65) splicing at the end
-splice(@a, 3, 0, "rec4");
-check();
-splice(@a, 3, 1, "rec5");       # same length
-check();
-splice(@a, 3, 1, "record5");    # longer
-check();
-splice(@a, 3, 1, "r5");         # shorter
-check();
-splice(@a, 3, 1);               # removal
-check();
-splice(@a, 3, 0);               # no-op
-check();
-
-splice(@a, 3, 0, 'r7', 'rec8'); # insert more than one
-check();
-splice(@a, 3, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check();
-splice(@a, 3, 3, 'record9', 'rec10'); # delete more than insert
-check();
-splice(@a, 3, 2);               # delete more than one
-check();
-
-# (66-85) splicing with negative subscript
-splice(@a, -1, 0, "rec4");
-check();
-splice(@a, -1, 1, "rec5");       # same length
-check();
-splice(@a, -1, 1, "record5");    # longer
-check();
-splice(@a, -1, 1, "r5");         # shorter
-check();
-splice(@a, -1, 1);               # removal
-check();
-splice(@a, -1, 0);               # no-op  
-check();
-
-splice(@a, -1, 0, 'r7', 'rec8'); # insert more than one
-check();
-splice(@a, -1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check();
-splice(@a, -3, 3, 'record9', 'rec10'); # delete more than insert
-check();
-splice(@a, -4, 3);               # delete more than one
-check();
-
-# (86-87) scrub it all out
-splice(@a, 0, 3);
-check();
-
-# (88-89) put some back in
-splice(@a, 0, 0, "rec0", "rec1");
-check();
-
-# (90-91) what if we remove too many records?
-splice(@a, 0, 17);
-check();
-
-# (92-95) In the past, splicing past the end was not correctly detected
-# (1.14)
-splice(@a, 89, 3);
-check();
-splice(@a, @a, 3);
-check();
-
-# (96-99) Also we did not emulate splice's freaky behavior when inserting
-# past the end of the array (1.14)
-splice(@a, 89, 0, "I", "like", "pie");
-check();
-splice(@a, 89, 0, "pie pie pie");
-check();
-
-# (100-105) Test default arguments
-splice @a, 0, 0, (0..11);
-check();
-splice @a, 4;
-check();
-splice @a;
-check();
-
-# (106-111) One last set of tests.  I don't know what state the cache
-# is in now.  But if I read any three records, those three records are
-# what should be in the cache, and nothing else.
-@a = "record0" .. "record9";
-check(); # In 0.18 #107 fails here--STORE was not flushing the cache when
-         # replacing an old cached record with a longer one
-for (5, 6, 1) { my $z = $a[$_] }
-{
-  my $x = "5 6 1";
-  my $a = join " ", $o->{cache}->_produce_lru;
-  if ($a eq $x) { print "ok $N\n" }
-  else { print "not ok $N # LRU was <$a>; expected <$x>\n" }
-  $N++;
-  $x = "1 5 6";
-  $a = join " ", sort $o->{cache}->ckeys;
-  if ($a eq $x) { print "ok $N\n" }
-  else { print "not ok $N # cache keys were <$a>; expected <$x>\n" }
-  $N++;
-}
-check();
-
-
-sub init_file {
-  my $data = shift;
-  open F, "> $file" or die $!;
-  binmode F;
-  print F $data;
-  close F;
-}
-
-sub check {
-  my $integrity = $o->_check_integrity($file, $ENV{INTEGRITY});
-  print $integrity ? "ok $N\n" : "not ok $N\n";
-  $N++;
-
-  my $b = $o->{cache}->bytes;
-  print $b <= $MAX 
-    ? "ok $N\n" 
-    : "not ok $N # $b bytes cached, should be <= $MAX\n";
-  $N++;
-}
-
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
-
-
diff --git a/ext/Tie-File/t/21_win32.t b/ext/Tie-File/t/21_win32.t
deleted file mode 100644
index d06854441b..0000000000
--- a/ext/Tie-File/t/21_win32.t
+++ /dev/null
@@ -1,61 +0,0 @@
-#!/usr/bin/perl
-#
-# Formerly, on a Win32 system, Tie::File would create files with
-# \n-terminated records instead of \r\n-terminated.  The tests never
-# picked this up because they were using $/ everywhere, and $/ is \n
-# on windows systems.
-#
-# These tests (Win32 only) make sure that the file had \r\n as it should.
-
-my $file = "tf$$.txt";
-
-unless ($^O =~ /^(MSWin32|dos)$/) {
-  print "1..0\n";
-  exit;
-}
-
-
-print "1..3\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-my $o = tie @a, 'Tie::File', $file, autodefer => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-my $n;
-
-# (3) Make sure that on Win32 systems, the file is written with \r\n by default
-@a = qw(fish dog carrot);
-undef $o;
-untie @a;
-open F, "< $file" or die "Couldn't open file $file: $!";
-binmode F;
-my $a = do {local $/ ; <F> };
-my $x = "fish\r\ndog\r\ncarrot\r\n" ;
-if ($a eq $x) {
-  print "ok $N\n";
-} else {
-  ctrlfix(my $msg = "expected <$x>, got <$a>");
-  print "not ok $N # $msg\n";
-}
-
-close F;
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/22_autochomp.t b/ext/Tie-File/t/22_autochomp.t
deleted file mode 100644
index dee07a8ec8..0000000000
--- a/ext/Tie-File/t/22_autochomp.t
+++ /dev/null
@@ -1,175 +0,0 @@
-#!/usr/bin/perl
-
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-
-print "1..71\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-my $o = tie @a, 'Tie::File', $file, autochomp => 1, autodefer => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# 3-5 create
-$a[0] = 'rec0';
-check_contents("rec0");
-
-# 6-11 append
-$a[1] = 'rec1';
-check_contents("rec0", "rec1");
-$a[2] = 'rec2';
-check_contents("rec0", "rec1", "rec2");
-
-# 12-20 same-length alterations
-$a[0] = 'new0';
-check_contents("new0", "rec1", "rec2");
-$a[1] = 'new1';
-check_contents("new0", "new1", "rec2");
-$a[2] = 'new2';
-check_contents("new0", "new1", "new2");
-
-# 21-35 lengthening alterations
-$a[0] = 'long0';
-check_contents("long0", "new1", "new2");
-$a[1] = 'long1';
-check_contents("long0", "long1", "new2");
-$a[2] = 'long2';
-check_contents("long0", "long1", "long2");
-$a[1] = 'longer1';
-check_contents("long0", "longer1", "long2");
-$a[0] = 'longer0';
-check_contents("longer0", "longer1", "long2");
-
-# 36-50 shortening alterations, including truncation
-$a[0] = 'short0';
-check_contents("short0", "longer1", "long2");
-$a[1] = 'short1';
-check_contents("short0", "short1", "long2");
-$a[2] = 'short2';
-check_contents("short0", "short1", "short2");
-$a[1] = 'sh1';
-check_contents("short0", "sh1", "short2");
-$a[0] = 'sh0';
-check_contents("sh0", "sh1", "short2");
-
-# (51-56) file with holes
-$a[4] = 'rec4';
-check_contents("sh0", "sh1", "short2", "", "rec4");
-$a[3] = 'rec3';
-check_contents("sh0", "sh1", "short2", "rec3", "rec4");
-
-# (57-59) zero out file
-@a = ();
-check_contents();
-
-# (60-62) insert into the middle of an empty file
-$a[3] = "rec3";
-check_contents("", "", "", "rec3");
-
-# (63-68) Test the ->autochomp() method
-@a = qw(Gold Frankincense Myrrh);
-my $ac;
-$ac = $o->autochomp();
-expect($ac);
-# See if that accidentally changed it
-$ac = $o->autochomp();
-expect($ac);
-# Now clear it
-$ac = $o->autochomp(0);
-expect($ac);
-expect(join("-", @a), "Gold$:-Frankincense$:-Myrrh$:");
-# Now set it again
-$ac = $o->autochomp(1);
-expect(!$ac);
-expect(join("-", @a), "Gold-Frankincense-Myrrh");
-
-# (69) Does 'splice' work correctly with autochomp?
-my @sr;
-@sr = splice @a, 0, 2;
-expect(join("-", @sr), "Gold-Frankincense");
-
-# (70-71) Didn't you forget that fetch may return an unchomped cached record?
-$a1 = $a[0];                    # populate cache
-$a2 = $a[0];
-expect($a1, "Myrrh");
-expect($a2, "Myrrh");
-# Actually no, you didn't---_fetch might return such a record, but 
-# the chomping is done by FETCH.
-
-use POSIX 'SEEK_SET';
-sub check_contents {
-  my @c = @_;
-  my $x = join $:, @c, '';
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-#  my $open = open FH, "< $file";
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix($a, $x);
-    print "not ok $N\n# expected <$x>, got <$a>\n";
-  }
-  $N++;
-
-  # now check FETCH:
-  my $good = 1;
-  my $msg;
-  for (0.. $#c) {
-    my $aa = $a[$_];
-    unless ($aa eq $c[$_]) {
-      $msg = "expected <$c[$_]>, got <$aa>";
-      ctrlfix($msg);
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N # $msg\n";
-  $N++;
-
-  print $o->_check_integrity($file, $ENV{INTEGRITY}) 
-      ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-sub expect {
-  if (@_ == 1) {
-    print $_[0] ? "ok $N\n" : "not ok $N\n";
-  } elsif (@_ == 2) {
-    my ($a, $x) = @_;
-    if    (! defined($a) && ! defined($x)) { print "ok $N\n" }
-    elsif (  defined($a) && ! defined($x)) { 
-      ctrlfix(my $msg = "expected UNDEF, got <$a>");
-      print "not ok $N \# $msg\n";
-    }
-    elsif (! defined($a) &&   defined($x)) { 
-      ctrlfix(my $msg = "expected <$x>, got UNDEF");
-      print "not ok $N \# $msg\n";
-    } elsif ($a eq $x) { print "ok $N\n" }
-    else {
-      ctrlfix(my $msg = "expected <$x>, got <$a>");
-      print "not ok $N \# $msg\n";
-    }
-  } else {
-    die "expect() got ", scalar(@_), " args, should have been 1 or 2";
-  }
-  $N++;
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/23_rv_ac_splice.t b/ext/Tie-File/t/23_rv_ac_splice.t
deleted file mode 100644
index be229574f9..0000000000
--- a/ext/Tie-File/t/23_rv_ac_splice.t
+++ /dev/null
@@ -1,182 +0,0 @@
-#!/usr/bin/perl
-#
-# Check SPLICE function's return value when autochoping is now
-# (07_rv_splice.t checks it aith autochomping off)
-#
-
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-my $data = "rec0$:rec1$:rec2$:";
-
-print "1..50\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;  # partial credit just for showing up
-
-init_file($data);
-
-my $o = tie @a, 'Tie::File', $file, autochomp => 1;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-my $n;
-
-# (3-12) splicing at the beginning
-@r = splice(@a, 0, 0, "rec4");
-check_result();
-@r = splice(@a, 0, 1, "rec5");       # same length
-check_result("rec4");
-@r = splice(@a, 0, 1, "record5");    # longer
-check_result("rec5");
-
-@r = splice(@a, 0, 1, "r5");         # shorter
-check_result("record5");
-@r = splice(@a, 0, 1);               # removal
-check_result("r5");
-@r = splice(@a, 0, 0);               # no-op
-check_result();
-@r = splice(@a, 0, 0, 'r7', 'rec8'); # insert more than one
-check_result();
-@r = splice(@a, 0, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_result('r7', 'rec8');
-
-@r = splice(@a, 0, 3, 'record9', 'rec10'); # delete more than insert
-check_result('rec7', 'record8', 'rec9');
-@r = splice(@a, 0, 2);               # delete more than one
-check_result('record9', 'rec10');
-
-
-# (13-22) splicing in the middle
-@r = splice(@a, 1, 0, "rec4");
-check_result();
-@r = splice(@a, 1, 1, "rec5");       # same length
-check_result('rec4');
-@r = splice(@a, 1, 1, "record5");    # longer
-check_result('rec5');
-
-@r = splice(@a, 1, 1, "r5");         # shorter
-check_result("record5");
-@r = splice(@a, 1, 1);               # removal
-check_result("r5");
-@r = splice(@a, 1, 0);               # no-op
-check_result();
-@r = splice(@a, 1, 0, 'r7', 'rec8'); # insert more than one
-check_result();
-@r = splice(@a, 1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_result('r7', 'rec8');
-
-@r = splice(@a, 1, 3, 'record9', 'rec10'); # delete more than insert
-check_result('rec7', 'record8', 'rec9');
-@r = splice(@a, 1, 2);               # delete more than one
-check_result('record9','rec10');
-
-# (23-32) splicing at the end
-@r = splice(@a, 3, 0, "rec4");
-check_result();
-@r = splice(@a, 3, 1, "rec5");       # same length
-check_result('rec4');
-@r = splice(@a, 3, 1, "record5");    # longer
-check_result('rec5');
-
-@r = splice(@a, 3, 1, "r5");         # shorter
-check_result('record5');
-@r = splice(@a, 3, 1);               # removal
-check_result('r5');
-@r = splice(@a, 3, 0);               # no-op
-check_result();
-@r = splice(@a, 3, 0, 'r7', 'rec8'); # insert more than one
-check_result();
-@r = splice(@a, 3, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_result('r7', 'rec8');
-
-@r = splice(@a, 3, 3, 'record9', 'rec10'); # delete more than insert
-check_result('rec7', 'record8', 'rec9');
-@r = splice(@a, 3, 2);               # delete more than one
-check_result('record9', 'rec10');
-
-# (33-42) splicing with negative subscript
-@r = splice(@a, -1, 0, "rec4");
-check_result();
-@r = splice(@a, -1, 1, "rec5");       # same length
-check_result('rec2');
-@r = splice(@a, -1, 1, "record5");    # longer
-check_result("rec5");
-
-@r = splice(@a, -1, 1, "r5");         # shorter
-check_result("record5");
-@r = splice(@a, -1, 1);               # removal
-check_result("r5");
-@r = splice(@a, -1, 0);               # no-op  
-check_result();
-@r = splice(@a, -1, 0, 'r7', 'rec8'); # insert more than one
-check_result();
-@r = splice(@a, -1, 2, 'rec7', 'record8', 'rec9'); # insert more than delete
-check_result('rec4');
-
-@r = splice(@a, -3, 3, 'record9', 'rec10'); # delete more than insert
-check_result('rec7', 'record8', 'rec9');
-@r = splice(@a, -4, 3);               # delete more than one
-check_result('r7', 'rec8', 'record9');
-
-# (43) scrub it all out
-@r = splice(@a, 0, 3);
-check_result('rec0', 'rec1', 'rec10');
-
-# (44) put some back in
-@r = splice(@a, 0, 0, "rec0", "rec1");
-check_result();
-
-# (45) what if we remove too many records?
-@r = splice(@a, 0, 17);
-check_result('rec0', 'rec1');
-
-# (46-48) Now check the scalar context return
-splice(@a, 0, 0, qw(I like pie));
-my $r;
-$r = splice(@a, 0, 0);
-print !defined($r) ? "ok $N\n" : "not ok $N \# return should have been undef, was <$r>\n";
-$N++;
-
-$r = splice(@a, 2, 1);
-print $r eq "pie" ? "ok $N\n" : "not ok $N \# return should have been 'pie', was <$r>\n";
-$N++;
-
-$r = splice(@a, 0, 2);
-print $r eq "like" ? "ok $N\n" : "not ok $N \# return should have been 'like', was <$r>\n";
-$N++;
-
-# (49-50) Test default arguments
-splice @a, 0, 0, (0..11);
-@r = splice @a, 4;
-check_result(4..11);
-@r = splice @a;
-check_result(0..3);
-
-sub init_file {
-  my $data = shift;
-  open F, "> $file" or die $!;
-  binmode F;
-  print F $data;
-  close F;
-}
-
-# actual results are in @r.
-# expected results are in @_
-sub check_result {
-  my @x = @_;
-  my $good = 1;
-  $good = 0 unless @r == @x;
-  for my $i (0 .. $#r) {
-    $good = 0 unless $r[$i] eq $x[$i];
-  }
-  print $good ? "ok $N\n" : "not ok $N \# was (@r); should be (@x)\n";
-  $N++;
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/24_cache_loop.t b/ext/Tie-File/t/24_cache_loop.t
deleted file mode 100644
index 0bc66bee2b..0000000000
--- a/ext/Tie-File/t/24_cache_loop.t
+++ /dev/null
@@ -1,55 +0,0 @@
-#!/usr/bin/perl
-#
-# Tests for various caching errors
-#
-
-use Config;
-my $file = "tf$$.txt";
-unless ($Config{d_alarm}) {
-  print "1..0\n"; exit;
-}
-
-$: = Tie::File::_default_recsep();
-my $data = join $:, "record0" .. "record9", "";
-my $V = $ENV{INTEGRITY};        # Verbose integrity checking?
-
-print "1..3\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-open F, "> $file" or die $!;
-binmode F;
-print F $data;
-close F;
-
-# Limit cache size to 30 bytes 
-my $MAX = 30;
-#  -- that's enough space for 3 records, but not 4, on both \n and \r\n systems
-my $o = tie @a, 'Tie::File', $file, memory => $MAX, autodefer => 1;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# (3) In 0.50 this goes into an infinite loop.  Explanation:
-#
-#   Suppose you overfill the defer buffer by so much that the memory
-#   limit is also exceeded.  You'll go into _splice to prepare to
-#   write out the defer buffer, and _splice will call _fetch, which
-#   will then try to flush the read cache---but the read cache is
-#   already empty, so you're stuck in an infinite loop.
-#
-# Five seconds should be plenty of time for it to complete if it works.
-alarm 5 unless $^P;
-@a = "record0" .. "record9";
-print "ok 3\n";
-alarm 0;
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
-
-
diff --git a/ext/Tie-File/t/25_gen_nocache.t b/ext/Tie-File/t/25_gen_nocache.t
deleted file mode 100644
index 78e5506215..0000000000
--- a/ext/Tie-File/t/25_gen_nocache.t
+++ /dev/null
@@ -1,137 +0,0 @@
-#!/usr/bin/perl
-#
-# Regular read-write tests with caching disabled
-# (Same as 01_gen.t)
-#
-my $file = "tf$$.txt";
-
-print "1..68\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-my $o = tie @a, 'Tie::File', $file, autochomp => 0, autodefer => 0, memory => 0;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-$: = $o->{recsep};
-
-# 3-5 create
-$a[0] = 'rec0';
-check_contents("rec0");
-
-# 6-11 append
-$a[1] = 'rec1';
-check_contents("rec0", "rec1");
-$a[2] = 'rec2';
-check_contents("rec0", "rec1", "rec2");
-
-# 12-20 same-length alterations
-$a[0] = 'new0';
-check_contents("new0", "rec1", "rec2");
-$a[1] = 'new1';
-check_contents("new0", "new1", "rec2");
-$a[2] = 'new2';
-check_contents("new0", "new1", "new2");
-
-# 21-35 lengthening alterations
-$a[0] = 'long0';
-check_contents("long0", "new1", "new2");
-$a[1] = 'long1';
-check_contents("long0", "long1", "new2");
-$a[2] = 'long2';
-check_contents("long0", "long1", "long2");
-$a[1] = 'longer1';
-check_contents("long0", "longer1", "long2");
-$a[0] = 'longer0';
-check_contents("longer0", "longer1", "long2");
-
-# 36-50 shortening alterations, including truncation
-$a[0] = 'short0';
-check_contents("short0", "longer1", "long2");
-$a[1] = 'short1';
-check_contents("short0", "short1", "long2");
-$a[2] = 'short2';
-check_contents("short0", "short1", "short2");
-$a[1] = 'sh1';
-check_contents("short0", "sh1", "short2");
-$a[0] = 'sh0';
-check_contents("sh0", "sh1", "short2");
-
-# (51-56) file with holes
-$a[4] = 'rec4';
-check_contents("sh0", "sh1", "short2", "", "rec4");
-$a[3] = 'rec3';
-check_contents("sh0", "sh1", "short2", "rec3", "rec4");
-
-# (57-59) zero out file
-@a = ();
-check_contents();
-
-# (60-62) insert into the middle of an empty file
-$a[3] = "rec3";
-check_contents("", "", "", "rec3");
-
-# (63-68) 20020326 You thought there would be a bug in STORE where if
-# a cached record was false, STORE wouldn't see it at all.  But you
-# forgot that records always come back from the cache with the record
-# separator attached, so they are unlikely to be false.  The only
-# really weird case is when the cached record is empty and the record
-# separator is "0".  Test that in 09_gen_rs.t.
-$a[1] = "0";
-check_contents("", "0", "", "rec3");
-$a[1] = "whoops";
-check_contents("", "whoops", "", "rec3");
-
-
-use POSIX 'SEEK_SET';
-sub check_contents {
-  my @c = @_;
-  my $x = join $:, @c, '';
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-#  my $open = open FH, "< $file";
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix($a, $x);
-    print "not ok $N\n# expected <$x>, got <$a>\n";
-  }
-  $N++;
-
-  # now check FETCH:
-  my $good = 1;
-  my $msg;
-  for (0.. $#c) {
-    my $aa = $a[$_];
-    unless ($aa eq "$c[$_]$:") {
-      $msg = "expected <$c[$_]$:>, got <$aa>";
-      ctrlfix($msg);
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N # $msg\n";
-  $N++;
-
-  print $o->_check_integrity($file, $ENV{INTEGRITY}) 
-      ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/26_twrite.t b/ext/Tie-File/t/26_twrite.t
deleted file mode 100644
index e2a925f4e0..0000000000
--- a/ext/Tie-File/t/26_twrite.t
+++ /dev/null
@@ -1,359 +0,0 @@
-#!/usr/bin/perl
-#
-# Unit tests of _twrite function
-#
-# _twrite($self, $data, $pos, $len)
-#
-# 't' here is for 'tail'.  This writes $data at absolute position $pos
-# in the file, overwriting exactly $len of the bytes at that position.
-# Everything else is moved down or up, dependong on whether
-# length($data) > $len or length($data) < $len.
-# $len == 0 is a pure insert; $len == length($data) is a simple overwrite.
-#
-
-my $file = "tf$$.txt";
-
-print "1..181\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-$: = Tie::File::_default_recsep();
-
-# (2) Peter Scott sent this one.  It fails in 0.51 and works in 0.90
-# <4.3.2.7.2.20020331102819.00b913d0@shell2.webquarry.com>
-#
-# The problem was premature termination in the inner loop
-# because you had $more_data scoped *inside* the block instead of outside.
-# 20020331
-open F, "> $file" or die "Couldn't open $file: $!";
-binmode F;
-for (1..100) {
-  print F "$_ ", 'a'x150, $: ;
-}
-close F;
-# The file is now 15292 characters long on Unix, 15392 on Win32
-die -s $file unless -s $file == 15292 + 100 * length($:);
-
-tie my @lines, 'Tie::File', $file or die $!;
-push @lines, "1001 ".('a' x 100);
-splice @lines, 0, 1;
-untie @lines;
-
-my $s = -s $file;
-my $x = 15292 - 152 + 105 + 100*length($:);
-print $s == $x
-  ? "ok $N\n" : "not ok $N # expected $x, got $s\n";
-$N++;
-
-my @subtests = qw(x <x x> x><x <x> <x><x x><x> <x><x> <x><x><x> 0);
-
-# (3-73) These were generated by 'gentests.pl' to cover all possible cases
-# (I hope)
-# Legend:
-#         x: data is entirely contained within one block
-#        x>: data runs from the middle to the end of the block
-#        <x: data runs from the start to the middle of the block
-#       <x>: data occupies precisely one block
-#      x><x: data overlaps one block boundary
-#     <x><x: data runs from the start of one block into the middle of the next
-#     x><x>: data runs from the middle of one block to the end of the next
-#    <x><x>: data occupies two blocks exactly
-# <x><x><x>: data occupies three blocks exactly
-#         0: data is null
-#
-# For each possible alignment of the old and new data, we investigate
-# up to three situations: old data is shorter, old and new data are the
-# same length, and new data is shorter.
-#
-# try($pos, $old, $new) means to run a test where the data starts at 
-# position $pos, the old data has length $old,
-# and the new data has length $new.
-try( 9659,  6635,  6691);  # old=x        , new=x        ; old < new
-try( 8605,  2394,  2394);  # old=x        , new=x        ; old = new
-try( 9768,  1361,   664);  # old=x        , new=x        ; old > new
-try( 9955,  6429,  6429);  # old=x>       , new=x        ; old = new
-try(10550,  5834,  4123);  # old=x>       , new=x        ; old > new
-try(14580,  6158,   851);  # old=x><x     , new=x        ; old > new
-try(13442, 11134,  1572);  # old=x><x>    , new=x        ; old > new
-try( 8394,     0,  5742);  # old=0        , new=x        ; old < new
-try( 8192,  2819,  6738);  # old=<x       , new=<x       ; old < new
-try( 8192,   514,   514);  # old=<x       , new=<x       ; old = new
-try( 8192,  2196,   858);  # old=<x       , new=<x       ; old > new
-try( 8192,  8192,  8192);  # old=<x>      , new=<x       ; old = new
-try( 8192,  8192,  1290);  # old=<x>      , new=<x       ; old > new
-try( 8192, 10575,  6644);  # old=<x><x    , new=<x       ; old > new
-try( 8192, 16384,  5616);  # old=<x><x>   , new=<x       ; old > new
-try( 8192, 24576,  6253);  # old=<x><x><x>, new=<x       ; old > new
-try( 8192,     0,  6870);  # old=0        , new=<x       ; old < new
-try( 8478,  6259,  7906);  # old=x        , new=x>       ; old < new
-try( 9965,  6419,  6419);  # old=x>       , new=x>       ; old = new
-try(16059,  6102,   325);  # old=x><x     , new=x>       ; old > new
-try( 9503, 15073,  6881);  # old=x><x>    , new=x>       ; old > new
-try( 9759,     0,  6625);  # old=0        , new=x>       ; old < new
-try( 8525,  2081,  8534);  # old=x        , new=x><x     ; old < new
-try(15550,   834,  1428);  # old=x>       , new=x><x     ; old < new
-try(14966,  1668,  3479);  # old=x><x     , new=x><x     ; old < new
-try(16316,  1605,  1605);  # old=x><x     , new=x><x     ; old = new
-try(16093,  4074,   993);  # old=x><x     , new=x><x     ; old > new
-try(14739,  9837,  9837);  # old=x><x>    , new=x><x     ; old = new
-try(14071, 10505,  7344);  # old=x><x>    , new=x><x     ; old > new
-try(12602,     0,  8354);  # old=0        , new=x><x     ; old < new
-try( 8192,  2767,  8192);  # old=<x       , new=<x>      ; old < new
-try( 8192,  8192,  8192);  # old=<x>      , new=<x>      ; old = new
-try( 8192, 14817,  8192);  # old=<x><x    , new=<x>      ; old > new
-try( 8192, 16384,  8192);  # old=<x><x>   , new=<x>      ; old > new
-try( 8192, 24576,  8192);  # old=<x><x><x>, new=<x>      ; old > new
-try( 8192,     0,  8192);  # old=0        , new=<x>      ; old < new
-try( 8192,  6532, 10882);  # old=<x       , new=<x><x    ; old < new
-try( 8192,  8192, 16044);  # old=<x>      , new=<x><x    ; old < new
-try( 8192,  9555, 11020);  # old=<x><x    , new=<x><x    ; old < new
-try( 8192,  9001,  9001);  # old=<x><x    , new=<x><x    ; old = new
-try( 8192, 11760, 10274);  # old=<x><x    , new=<x><x    ; old > new
-try( 8192, 16384, 10781);  # old=<x><x>   , new=<x><x    ; old > new
-try( 8192, 24576,  9284);  # old=<x><x><x>, new=<x><x    ; old > new
-try( 8192,     0, 12488);  # old=0        , new=<x><x    ; old < new
-try( 8222,  6385, 16354);  # old=x        , new=x><x>    ; old < new
-try(13500,  2884, 11076);  # old=x>       , new=x><x>    ; old < new
-try(14069,  4334, 10507);  # old=x><x     , new=x><x>    ; old < new
-try(14761,  9815,  9815);  # old=x><x>    , new=x><x>    ; old = new
-try(10469,     0, 14107);  # old=0        , new=x><x>    ; old < new
-try( 8192,  4181, 16384);  # old=<x       , new=<x><x>   ; old < new
-try( 8192,  8192, 16384);  # old=<x>      , new=<x><x>   ; old < new
-try( 8192, 12087, 16384);  # old=<x><x    , new=<x><x>   ; old < new
-try( 8192, 16384, 16384);  # old=<x><x>   , new=<x><x>   ; old = new
-try( 8192, 24576, 16384);  # old=<x><x><x>, new=<x><x>   ; old > new
-try( 8192,     0, 16384);  # old=0        , new=<x><x>   ; old < new
-try( 8192,  4968, 24576);  # old=<x       , new=<x><x><x>; old < new
-try( 8192,  8192, 24576);  # old=<x>      , new=<x><x><x>; old < new
-try( 8192, 14163, 24576);  # old=<x><x    , new=<x><x><x>; old < new
-try( 8192, 16384, 24576);  # old=<x><x>   , new=<x><x><x>; old < new
-try( 8192, 24576, 24576);  # old=<x><x><x>, new=<x><x><x>; old = new
-try( 8192,     0, 24576);  # old=0        , new=<x><x><x>; old < new
-try( 8771,   776,     0);  # old=x        , new=0        ; old > new
-try( 8192,  2813,     0);  # old=<x       , new=0        ; old > new
-try(13945,  2439,     0);  # old=x>       , new=0        ; old > new
-try(14493,  6090,     0);  # old=x><x     , new=0        ; old > new
-try( 8192,  8192,     0);  # old=<x>      , new=0        ; old > new
-try( 8192, 10030,     0);  # old=<x><x    , new=0        ; old > new
-try(14983,  9593,     0);  # old=x><x>    , new=0        ; old > new
-try( 8192, 16384,     0);  # old=<x><x>   , new=0        ; old > new
-try( 8192, 24576,     0);  # old=<x><x><x>, new=0        ; old > new
-try(10489,     0,     0);  # old=0        , new=0        ; old = new
-
-# (74-114)
-# These tests all take place at the start of the file
-try(    0,   771,  1593);  # old=<x       , new=<x       ; old < new
-try(    0,  4868,  4868);  # old=<x       , new=<x       ; old = new
-try(    0,   147,   118);  # old=<x       , new=<x       ; old > new
-try(    0,  8192,  8192);  # old=<x>      , new=<x       ; old = new
-try(    0,  8192,  4574);  # old=<x>      , new=<x       ; old > new
-try(    0, 11891,  1917);  # old=<x><x    , new=<x       ; old > new
-try(    0, 16384,  5155);  # old=<x><x>   , new=<x       ; old > new
-try(    0, 24576,  2953);  # old=<x><x><x>, new=<x       ; old > new
-try(    0,     0,  1317);  # old=0        , new=<x       ; old < new
-try(    0,  5609,  8192);  # old=<x       , new=<x>      ; old < new
-try(    0,  8192,  8192);  # old=<x>      , new=<x>      ; old = new
-try(    0, 11083,  8192);  # old=<x><x    , new=<x>      ; old > new
-try(    0, 16384,  8192);  # old=<x><x>   , new=<x>      ; old > new
-try(    0, 24576,  8192);  # old=<x><x><x>, new=<x>      ; old > new
-try(    0,     0,  8192);  # old=0        , new=<x>      ; old < new
-try(    0,  6265,  9991);  # old=<x       , new=<x><x    ; old < new
-try(    0,  8192, 16119);  # old=<x>      , new=<x><x    ; old < new
-try(    0, 10218, 11888);  # old=<x><x    , new=<x><x    ; old < new
-try(    0, 14126, 14126);  # old=<x><x    , new=<x><x    ; old = new
-try(    0, 12002,  9034);  # old=<x><x    , new=<x><x    ; old > new
-try(    0, 16384, 13258);  # old=<x><x>   , new=<x><x    ; old > new
-try(    0, 24576, 14367);  # old=<x><x><x>, new=<x><x    ; old > new
-try(    0,     0, 10881);  # old=0        , new=<x><x    ; old < new
-try(    0,  6448, 16384);  # old=<x       , new=<x><x>   ; old < new
-try(    0,  8192, 16384);  # old=<x>      , new=<x><x>   ; old < new
-try(    0, 15082, 16384);  # old=<x><x    , new=<x><x>   ; old < new
-try(    0, 16384, 16384);  # old=<x><x>   , new=<x><x>   ; old = new
-try(    0, 24576, 16384);  # old=<x><x><x>, new=<x><x>   ; old > new
-try(    0,     0, 16384);  # old=0        , new=<x><x>   ; old < new
-try(    0,  2421, 24576);  # old=<x       , new=<x><x><x>; old < new
-try(    0,  8192, 24576);  # old=<x>      , new=<x><x><x>; old < new
-try(    0, 11655, 24576);  # old=<x><x    , new=<x><x><x>; old < new
-try(    0, 16384, 24576);  # old=<x><x>   , new=<x><x><x>; old < new
-try(    0, 24576, 24576);  # old=<x><x><x>, new=<x><x><x>; old = new
-try(    0,     0, 24576);  # old=0        , new=<x><x><x>; old < new
-try(    0,  6530,     0);  # old=<x       , new=0        ; old > new
-try(    0,  8192,     0);  # old=<x>      , new=0        ; old > new
-try(    0, 14707,     0);  # old=<x><x    , new=0        ; old > new
-try(    0, 16384,     0);  # old=<x><x>   , new=0        ; old > new
-try(    0, 24576,     0);  # old=<x><x><x>, new=0        ; old > new
-try(    0,     0,     0);  # old=0        , new=0        ; old = new
-
-# (115-141)
-# These tests all take place at the end of the file
-$FLEN = 40960;  # Force the file to be exactly 40960 bytes long
-try(32768,  8192,  8192);  # old=<x>      , new=<x       ; old = new
-try(32768,  8192,  4026);  # old=<x>      , new=<x       ; old > new
-try(24576, 16384,  1917);  # old=<x><x>   , new=<x       ; old > new
-try(16384, 24576,  3818);  # old=<x><x><x>, new=<x       ; old > new
-try(40960,     0,  2779);  # old=0        , new=<x       ; old < new
-try(32768,  8192,  8192);  # old=<x>      , new=<x>      ; old = new
-try(24576, 16384,  8192);  # old=<x><x>   , new=<x>      ; old > new
-try(16384, 24576,  8192);  # old=<x><x><x>, new=<x>      ; old > new
-try(40960,     0,  8192);  # old=0        , new=<x>      ; old < new
-try(32768,  8192, 10724);  # old=<x>      , new=<x><x    ; old < new
-try(24576, 16384, 12221);  # old=<x><x>   , new=<x><x    ; old > new
-try(16384, 24576, 15030);  # old=<x><x><x>, new=<x><x    ; old > new
-try(40960,     0, 11752);  # old=0        , new=<x><x    ; old < new
-try(32768,  8192, 16384);  # old=<x>      , new=<x><x>   ; old < new
-try(24576, 16384, 16384);  # old=<x><x>   , new=<x><x>   ; old = new
-try(16384, 24576, 16384);  # old=<x><x><x>, new=<x><x>   ; old > new
-try(40960,     0, 16384);  # old=0        , new=<x><x>   ; old < new
-try(32768,  8192, 24576);  # old=<x>      , new=<x><x><x>; old < new
-try(24576, 16384, 24576);  # old=<x><x>   , new=<x><x><x>; old < new
-try(16384, 24576, 24576);  # old=<x><x><x>, new=<x><x><x>; old = new
-try(40960,     0, 24576);  # old=0        , new=<x><x><x>; old < new
-try(35973,  4987,     0);  # old=x>       , new=0        ; old > new
-try(32768,  8192,     0);  # old=<x>      , new=0        ; old > new
-try(29932, 11028,     0);  # old=x><x>    , new=0        ; old > new
-try(24576, 16384,     0);  # old=<x><x>   , new=0        ; old > new
-try(16384, 24576,     0);  # old=<x><x><x>, new=0        ; old > new
-try(40960,     0,     0);  # old=0        , new=0        ; old = new
-
-# (142-181)
-# These tests all take place at the end of the file
-$FLEN = 42000;  # Force the file to be exactly 42000 bytes long
-try(41275,   725,  4059);  # old=x        , new=x        ; old < new
-try(41683,   317,   317);  # old=x        , new=x        ; old = new
-try(41225,   775,   405);  # old=x        , new=x        ; old > new
-try(35709,  6291,   284);  # old=x><x     , new=x        ; old > new
-try(42000,     0,  2434);  # old=0        , new=x        ; old < new
-try(40960,  1040,  1608);  # old=<x       , new=<x       ; old < new
-try(40960,  1040,  1040);  # old=<x       , new=<x       ; old = new
-try(40960,  1040,   378);  # old=<x       , new=<x       ; old > new
-try(32768,  9232,  5604);  # old=<x><x    , new=<x       ; old > new
-try(42000,     0,  6637);  # old=0        , new=<x       ; old < new
-try(41022,   978,  8130);  # old=x        , new=x>       ; old < new
-try(39994,  2006,   966);  # old=x><x     , new=x>       ; old > new
-try(42000,     0,  7152);  # old=0        , new=x>       ; old < new
-try(41613,   387, 10601);  # old=x        , new=x><x     ; old < new
-try(38460,  3540,  3938);  # old=x><x     , new=x><x     ; old < new
-try(36725,  5275,  5275);  # old=x><x     , new=x><x     ; old = new
-try(37990,  4010,  3199);  # old=x><x     , new=x><x     ; old > new
-try(42000,     0,  9189);  # old=0        , new=x><x     ; old < new
-try(40960,  1040,  8192);  # old=<x       , new=<x>      ; old < new
-try(32768,  9232,  8192);  # old=<x><x    , new=<x>      ; old > new
-try(42000,     0,  8192);  # old=0        , new=<x>      ; old < new
-try(40960,  1040, 11778);  # old=<x       , new=<x><x    ; old < new
-try(32768,  9232, 13792);  # old=<x><x    , new=<x><x    ; old < new
-try(32768,  9232,  9232);  # old=<x><x    , new=<x><x    ; old = new
-try(32768,  9232,  8795);  # old=<x><x    , new=<x><x    ; old > new
-try(42000,     0,  8578);  # old=0        , new=<x><x    ; old < new
-try(41531,   469, 15813);  # old=x        , new=x><x>    ; old < new
-try(39618,  2382,  9534);  # old=x><x     , new=x><x>    ; old < new
-try(42000,     0, 15344);  # old=0        , new=x><x>    ; old < new
-try(40960,  1040, 16384);  # old=<x       , new=<x><x>   ; old < new
-try(32768,  9232, 16384);  # old=<x><x    , new=<x><x>   ; old < new
-try(42000,     0, 16384);  # old=0        , new=<x><x>   ; old < new
-try(40960,  1040, 24576);  # old=<x       , new=<x><x><x>; old < new
-try(32768,  9232, 24576);  # old=<x><x    , new=<x><x><x>; old < new
-try(42000,     0, 24576);  # old=0        , new=<x><x><x>; old < new
-try(41500,   500,     0);  # old=x        , new=0        ; old > new
-try(40960,  1040,     0);  # old=<x       , new=0        ; old > new
-try(35272,  6728,     0);  # old=x><x     , new=0        ; old > new
-try(32768,  9232,     0);  # old=<x><x    , new=0        ; old > new
-try(42000,     0,     0);  # old=0        , new=0        ; old = new
-
-sub try {
-  my ($pos, $len, $newlen) = @_;
-  open F, "> $file" or die "Couldn't open file $file: $!";
-  binmode F;
-
-  # The record has exactly 17 characters.  This will help ensure that
-  # even if _twrite screws up, the data doesn't coincidentally
-  # look good because the remainder accidentally lines up.
-  my $d = substr("0123456789abcdef$:", -17);
-  my $recs = defined($FLEN) ?
-    int($FLEN/length($d))+1 : # enough to make up at least $FLEN
-    int(8192*5/length($d))+1; # at least 5 blocks' worth
-  my $oldfile = $d x $recs;
-  my $flen = defined($FLEN) ? $FLEN : $recs * 17;
-  substr($oldfile, $FLEN) = "" if defined $FLEN;  # truncate
-  print F $oldfile;
-  close F;
-
-  die "wrong length!" unless -s $file == $flen;
-
-  my $newdata = "-" x $newlen;
-  my $expected = $oldfile;
-  substr($expected, $pos, $len) = $newdata;
-
-  my $o = tie my @lines, 'Tie::File', $file or die $!;
-  $o->_twrite($newdata, $pos, $len);
-  undef $o; untie @lines;
-
-  open F, "< $file" or die "Couldn't open file $file: $!";
-  binmode F;
-  my $actual;
-  { local $/;
-    $actual = <F>;
-  }
-  close F;
-
-  my ($alen, $xlen) = (length $actual, length $expected);
-  unless ($alen == $xlen) {
-    print "# try(@_) expected file length $xlen, actual $alen!\n";
-  }
-  print $actual eq $expected ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-
-
-use POSIX 'SEEK_SET';
-sub check_contents {
-  my @c = @_;
-  my $x = join $:, @c, '';
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-#  my $open = open FH, "< $file";
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix($a, $x);
-    print "not ok $N\n# expected <$x>, got <$a>\n";
-  }
-  $N++;
-
-  # now check FETCH:
-  my $good = 1;
-  my $msg;
-  for (0.. $#c) {
-    my $aa = $a[$_];
-    unless ($aa eq "$c[$_]$:") {
-      $msg = "expected <$c[$_]$:>, got <$aa>";
-      ctrlfix($msg);
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N # $msg\n";
-  $N++;
-
-  print $o->_check_integrity($file, $ENV{INTEGRITY}) 
-      ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/27_iwrite.t b/ext/Tie-File/t/27_iwrite.t
deleted file mode 100644
index db591a81ba..0000000000
--- a/ext/Tie-File/t/27_iwrite.t
+++ /dev/null
@@ -1,235 +0,0 @@
-#!/usr/bin/perl
-#
-# Unit tests of _iwrite function
-#
-# _iwrite($self, $data, $start, $end)
-#
-# 'i' here is for 'insert'.  This writes $data at absolute position $start
-# in the file, copying the data at that position downwards---
-# but only down to position $end.  Data at or past $end is not moved
-# or even examined.    Since there isn't enough room for the full copy
-# (Because we inserted $data at the beginning) we copy as much as possible
-# and return a string containing the remainder.
-
-my $file = "tf$$.txt";
-$| = 1;
-
-print "1..203\n";
-
-my $N = 1;
-my $oldfile;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-$: = Tie::File::_default_recsep();
-
-$FLEN = 40970;   # Use files of this length
-$oldfile = mkrand($FLEN);
-print "# MOF tests\n";
-# (2-85) These were generated by 'gentests.pl' to cover all possible cases
-# (I hope)
-# Legend:
-#         x: data is entirely contained within one block
-#        x>: data runs from the middle to the end of the block
-#        <x: data runs from the start to the middle of the block
-#       <x>: data occupies precisely one block
-#      x><x: data overlaps one block boundary
-#     <x><x: data runs from the start of one block into the middle of the next
-#     x><x>: data runs from the middle of one block to the end of the next
-#    <x><x>: data occupies two blocks exactly
-# <x><x><x>: data occupies three blocks exactly
-#         0: data is null
-#
-# For each possible alignment of the old and new data, we investigate
-# up to three situations: old data is shorter, old and new data are the
-# same length, and new data is shorter.
-#
-# try($pos, $old, $new) means to run a test where the area being
-# written into starts at position $pos, the area being written into
-# has length $old, and and the new data has length $new.
-try( 8605,  2394,  2394);  # old=x        , new=x        ; old = new
-try( 9768,  1361,   664);  # old=x        , new=x        ; old > new
-try( 9955,  6429,  6429);  # old=x>       , new=x        ; old = new
-try(10550,  5834,  4123);  # old=x>       , new=x        ; old > new
-try(14580,  6158,   851);  # old=x><x     , new=x        ; old > new
-try(13442, 11134,  1572);  # old=x><x>    , new=x        ; old > new
-try( 8192,   514,   514);  # old=<x       , new=<x       ; old = new
-try( 8192,  2196,   858);  # old=<x       , new=<x       ; old > new
-try( 8192,  8192,  8192);  # old=<x>      , new=<x       ; old = new
-try( 8192,  8192,  1290);  # old=<x>      , new=<x       ; old > new
-try( 8192, 10575,  6644);  # old=<x><x    , new=<x       ; old > new
-try( 8192, 16384,  5616);  # old=<x><x>   , new=<x       ; old > new
-try( 8192, 24576,  6253);  # old=<x><x><x>, new=<x       ; old > new
-try( 9965,  6419,  6419);  # old=x>       , new=x>       ; old = new
-try(16059,  6102,   325);  # old=x><x     , new=x>       ; old > new
-try( 9503, 15073,  6881);  # old=x><x>    , new=x>       ; old > new
-try(16316,  1605,  1605);  # old=x><x     , new=x><x     ; old = new
-try(16093,  4074,   993);  # old=x><x     , new=x><x     ; old > new
-try(14739,  9837,  9837);  # old=x><x>    , new=x><x     ; old = new
-try(14071, 10505,  7344);  # old=x><x>    , new=x><x     ; old > new
-try( 8192,  8192,  8192);  # old=<x>      , new=<x>      ; old = new
-try( 8192, 14817,  8192);  # old=<x><x    , new=<x>      ; old > new
-try( 8192, 16384,  8192);  # old=<x><x>   , new=<x>      ; old > new
-try( 8192, 24576,  8192);  # old=<x><x><x>, new=<x>      ; old > new
-try( 8192,  9001,  9001);  # old=<x><x    , new=<x><x    ; old = new
-try( 8192, 11760, 10274);  # old=<x><x    , new=<x><x    ; old > new
-try( 8192, 16384, 10781);  # old=<x><x>   , new=<x><x    ; old > new
-try( 8192, 24576,  9284);  # old=<x><x><x>, new=<x><x    ; old > new
-try(14761,  9815,  9815);  # old=x><x>    , new=x><x>    ; old = new
-try( 8192, 16384, 16384);  # old=<x><x>   , new=<x><x>   ; old = new
-try( 8192, 24576, 16384);  # old=<x><x><x>, new=<x><x>   ; old > new
-try( 8192, 24576, 24576);  # old=<x><x><x>, new=<x><x><x>; old = new
-try( 8771,   776,     0);  # old=x        , new=0        ; old > new
-try( 8192,  2813,     0);  # old=<x       , new=0        ; old > new
-try(13945,  2439,     0);  # old=x>       , new=0        ; old > new
-try(14493,  6090,     0);  # old=x><x     , new=0        ; old > new
-try( 8192,  8192,     0);  # old=<x>      , new=0        ; old > new
-try( 8192, 10030,     0);  # old=<x><x    , new=0        ; old > new
-try(14983,  9593,     0);  # old=x><x>    , new=0        ; old > new
-try( 8192, 16384,     0);  # old=<x><x>   , new=0        ; old > new
-try( 8192, 24576,     0);  # old=<x><x><x>, new=0        ; old > new
-try(10489,     0,     0);  # old=0        , new=0        ; old = new
-
-print "# SOF tests\n";
-# (86-133)
-# These tests all take place at the start of the file
-try(    0,  4868,  4868);  # old=<x       , new=<x       ; old = new
-try(    0,   147,   118);  # old=<x       , new=<x       ; old > new
-try(    0,  8192,  8192);  # old=<x>      , new=<x       ; old = new
-try(    0,  8192,  4574);  # old=<x>      , new=<x       ; old > new
-try(    0, 11891,  1917);  # old=<x><x    , new=<x       ; old > new
-try(    0, 16384,  5155);  # old=<x><x>   , new=<x       ; old > new
-try(    0, 24576,  2953);  # old=<x><x><x>, new=<x       ; old > new
-try(    0,  8192,  8192);  # old=<x>      , new=<x>      ; old = new
-try(    0, 11083,  8192);  # old=<x><x    , new=<x>      ; old > new
-try(    0, 16384,  8192);  # old=<x><x>   , new=<x>      ; old > new
-try(    0, 24576,  8192);  # old=<x><x><x>, new=<x>      ; old > new
-try(    0, 14126, 14126);  # old=<x><x    , new=<x><x    ; old = new
-try(    0, 12002,  9034);  # old=<x><x    , new=<x><x    ; old > new
-try(    0, 16384, 13258);  # old=<x><x>   , new=<x><x    ; old > new
-try(    0, 24576, 14367);  # old=<x><x><x>, new=<x><x    ; old > new
-try(    0, 16384, 16384);  # old=<x><x>   , new=<x><x>   ; old = new
-try(    0, 24576, 16384);  # old=<x><x><x>, new=<x><x>   ; old > new
-try(    0, 24576, 24576);  # old=<x><x><x>, new=<x><x><x>; old = new
-try(    0,  6530,     0);  # old=<x       , new=0        ; old > new
-try(    0,  8192,     0);  # old=<x>      , new=0        ; old > new
-try(    0, 14707,     0);  # old=<x><x    , new=0        ; old > new
-try(    0, 16384,     0);  # old=<x><x>   , new=0        ; old > new
-try(    0, 24576,     0);  # old=<x><x><x>, new=0        ; old > new
-try(    0,     0,     0);  # old=0        , new=0        ; old = new
-
-print "# EOF tests 1\n";
-# (134-169)
-# These tests all take place at the end of the file
-$FLEN = 40960;  # Force the file to be exactly 40960 bytes long
-$oldfile = mkrand($FLEN);
-try(32768,  8192,  8192);  # old=<x>      , new=<x       ; old = new
-try(32768,  8192,  4026);  # old=<x>      , new=<x       ; old > new
-try(24576, 16384,  1917);  # old=<x><x>   , new=<x       ; old > new
-try(16384, 24576,  3818);  # old=<x><x><x>, new=<x       ; old > new
-try(32768,  8192,  8192);  # old=<x>      , new=<x>      ; old = new
-try(24576, 16384,  8192);  # old=<x><x>   , new=<x>      ; old > new
-try(16384, 24576,  8192);  # old=<x><x><x>, new=<x>      ; old > new
-try(24576, 16384, 12221);  # old=<x><x>   , new=<x><x    ; old > new
-try(16384, 24576, 15030);  # old=<x><x><x>, new=<x><x    ; old > new
-try(24576, 16384, 16384);  # old=<x><x>   , new=<x><x>   ; old = new
-try(16384, 24576, 16384);  # old=<x><x><x>, new=<x><x>   ; old > new
-try(16384, 24576, 24576);  # old=<x><x><x>, new=<x><x><x>; old = new
-try(35973,  4987,     0);  # old=x>       , new=0        ; old > new
-try(32768,  8192,     0);  # old=<x>      , new=0        ; old > new
-try(29932, 11028,     0);  # old=x><x>    , new=0        ; old > new
-try(24576, 16384,     0);  # old=<x><x>   , new=0        ; old > new
-try(16384, 24576,     0);  # old=<x><x><x>, new=0        ; old > new
-try(40960,     0,     0);  # old=0        , new=0        ; old = new
-
-print "# EOF tests 2\n";
-# (170-203)
-# These tests all take place at the end of the file
-$FLEN = 42000;  # Force the file to be exactly 42000 bytes long
-$oldfile = mkrand($FLEN);
-try(41683,   317,   317);  # old=x        , new=x        ; old = new
-try(41225,   775,   405);  # old=x        , new=x        ; old > new
-try(35709,  6291,   284);  # old=x><x     , new=x        ; old > new
-try(40960,  1040,  1040);  # old=<x       , new=<x       ; old = new
-try(40960,  1040,   378);  # old=<x       , new=<x       ; old > new
-try(32768,  9232,  5604);  # old=<x><x    , new=<x       ; old > new
-try(39994,  2006,   966);  # old=x><x     , new=x>       ; old > new
-try(36725,  5275,  5275);  # old=x><x     , new=x><x     ; old = new
-try(37990,  4010,  3199);  # old=x><x     , new=x><x     ; old > new
-try(32768,  9232,  8192);  # old=<x><x    , new=<x>      ; old > new
-try(32768,  9232,  9232);  # old=<x><x    , new=<x><x    ; old = new
-try(32768,  9232,  8795);  # old=<x><x    , new=<x><x    ; old > new
-try(41500,   500,     0);  # old=x        , new=0        ; old > new
-try(40960,  1040,     0);  # old=<x       , new=0        ; old > new
-try(35272,  6728,     0);  # old=x><x     , new=0        ; old > new
-try(32768,  9232,     0);  # old=<x><x    , new=0        ; old > new
-try(42000,     0,     0);  # old=0        , new=0        ; old = new
-
-sub mkrand {
-  my $len = shift;
-  srand $len;
-  my @c = ('a' .. 'z', 'A' .. 'Z', 0..9, $:);
-  my $d = "";
-  $d .= $c[rand @c] until length($d) >= $len;
-  substr($d, $len) = ""; # chop it off to the proper length
-  $d;
-}
-
-sub try {
-  my ($s, $len, $newlen) = @_;
-  my $e = $s + $len;
-
-  open F, "> $file" or die "Couldn't open file $file: $!";
-  binmode F;
-
-  print F $oldfile;
-  close F;
-
-  die "wrong length!" unless -s $file == $FLEN;
-
-  my $newdata = "-" x $newlen;
-  my $expected = $oldfile;
-
-  my $expected_return = substr($expected, $e - $newlen, $newlen, "");
-  substr($expected, $s, 0, $newdata);
-
-  my $o = tie my @lines, 'Tie::File', $file or die $!;
-  my $actual_return = $o->_iwrite($newdata, $s, $e);
-  undef $o; untie @lines;
-
-  open F, "< $file" or die "Couldn't open file $file: $!";
-  binmode F;
-  my $actual;
-  { local $/;
-    $actual = <F>;
-  }
-  close F;
-
-  my ($alen, $xlen) = (length $actual, length $expected);
-  unless ($alen == $xlen) {
-    print "# try(@_) expected file length $xlen, actual $alen!\n";
-  }
-  print $actual eq $expected ? "ok $N\n" : "not ok $N\n";
-  $N++;
-
-  if (! defined $actual_return && ! defined $expected_return) {
-    print "ok $N\n";
-  } elsif (! defined $actual_return || ! defined $expected_return) {
-    print "not ok $N\n";
-  } else {
-    print $actual_return eq $expected_return ? "ok $N\n" : "not ok $N\n";
-  }
-  $N++;
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/28_mtwrite.t b/ext/Tie-File/t/28_mtwrite.t
deleted file mode 100644
index 50e306d3b6..0000000000
--- a/ext/Tie-File/t/28_mtwrite.t
+++ /dev/null
@@ -1,295 +0,0 @@
-#!/usr/bin/perl
-#
-# Unit tests of _mtwrite function
-#
-# _mtwrite($self, $d1, $s1, $l1, $d2, $s2, $l2, ...)
-#
-# 'm' here is for 'multiple'.  This writes data $d1 at position $s1
-# over a block of space $l1, moving subsequent data up or down as necessary.
-
-my $file = "tf$$.txt";
-$| = 1;
-
-print "1..2252\n";
-
-my $N = 1;
-my $oldfile;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-$: = Tie::File::_default_recsep();
-
-# Only these are used for the triple-region tests
-@BASE_TRIES = (
-               [10, 20, 30], 
-               [10, 30, 20], 
-               [100, 30, 20],
-               [100, 20, 30], 
-               [100, 40, 20], 
-               [100, 20, 40], 
-               [200, 20, 30],
-               [200, 30, 20],
-               [200, 20, 60],
-               [200, 60, 20],
-               );
-
-@TRIES = @BASE_TRIES;
-
-$FLEN = 40970;   # Use files of this length
-$oldfile = mkrand($FLEN);
-print "# MOF tests\n";
-# These were generated by 'gentests.pl' to cover all possible cases
-# (I hope)
-# Legend:
-#         x: data is entirely contained within one block
-#        x>: data runs from the middle to the end of the block
-#        <x: data runs from the start to the middle of the block
-#       <x>: data occupies precisely one block
-#      x><x: data overlaps one block boundary
-#     <x><x: data runs from the start of one block into the middle of the next
-#     x><x>: data runs from the middle of one block to the end of the next
-#    <x><x>: data occupies two blocks exactly
-# <x><x><x>: data occupies three blocks exactly
-#         0: data is null
-#
-# For each possible alignment of the old and new data, we investigate
-# up to three situations: old data is shorter, old and new data are the
-# same length, and new data is shorter.
-#
-# try($pos, $old, $new) means to run a test where the area being
-# written into starts at position $pos, the area being written into
-# has length $old, and and the new data has length $new.
-try( 8605,  2394,  2394);  # old=x        , new=x        ; old = new
-try( 9768,  1361,   664);  # old=x        , new=x        ; old > new
-try( 9955,  6429,  6429);  # old=x>       , new=x        ; old = new
-try(10550,  5834,  4123);  # old=x>       , new=x        ; old > new
-try(14580,  6158,   851);  # old=x><x     , new=x        ; old > new
-try(13442, 11134,  1572);  # old=x><x>    , new=x        ; old > new
-try( 8192,   514,   514);  # old=<x       , new=<x       ; old = new
-try( 8192,  2196,   858);  # old=<x       , new=<x       ; old > new
-try( 8192,  8192,  8192);  # old=<x>      , new=<x       ; old = new
-try( 8192,  8192,  1290);  # old=<x>      , new=<x       ; old > new
-try( 8192, 10575,  6644);  # old=<x><x    , new=<x       ; old > new
-try( 8192, 16384,  5616);  # old=<x><x>   , new=<x       ; old > new
-try( 8192, 24576,  6253);  # old=<x><x><x>, new=<x       ; old > new
-try( 9965,  6419,  6419);  # old=x>       , new=x>       ; old = new
-try(16059,  6102,   325);  # old=x><x     , new=x>       ; old > new
-try( 9503, 15073,  6881);  # old=x><x>    , new=x>       ; old > new
-try(16316,  1605,  1605);  # old=x><x     , new=x><x     ; old = new
-try(16093,  4074,   993);  # old=x><x     , new=x><x     ; old > new
-try(14739,  9837,  9837);  # old=x><x>    , new=x><x     ; old = new
-try(14071, 10505,  7344);  # old=x><x>    , new=x><x     ; old > new
-try( 8192,  8192,  8192);  # old=<x>      , new=<x>      ; old = new
-try( 8192, 14817,  8192);  # old=<x><x    , new=<x>      ; old > new
-try( 8192, 16384,  8192);  # old=<x><x>   , new=<x>      ; old > new
-try( 8192, 24576,  8192);  # old=<x><x><x>, new=<x>      ; old > new
-try( 8192,  9001,  9001);  # old=<x><x    , new=<x><x    ; old = new
-try( 8192, 11760, 10274);  # old=<x><x    , new=<x><x    ; old > new
-try( 8192, 16384, 10781);  # old=<x><x>   , new=<x><x    ; old > new
-try( 8192, 24576,  9284);  # old=<x><x><x>, new=<x><x    ; old > new
-try(14761,  9815,  9815);  # old=x><x>    , new=x><x>    ; old = new
-try( 8192, 16384, 16384);  # old=<x><x>   , new=<x><x>   ; old = new
-try( 8192, 24576, 16384);  # old=<x><x><x>, new=<x><x>   ; old > new
-try( 8192, 24576, 24576);  # old=<x><x><x>, new=<x><x><x>; old = new
-try( 8771,   776,     0);  # old=x        , new=0        ; old > new
-try( 8192,  2813,     0);  # old=<x       , new=0        ; old > new
-try(13945,  2439,     0);  # old=x>       , new=0        ; old > new
-try(14493,  6090,     0);  # old=x><x     , new=0        ; old > new
-try( 8192,  8192,     0);  # old=<x>      , new=0        ; old > new
-try( 8192, 10030,     0);  # old=<x><x    , new=0        ; old > new
-try(14983,  9593,     0);  # old=x><x>    , new=0        ; old > new
-try( 8192, 16384,     0);  # old=<x><x>   , new=0        ; old > new
-try( 8192, 24576,     0);  # old=<x><x><x>, new=0        ; old > new
-try(10489,     0,     0);  # old=0        , new=0        ; old = new
-
-print "# SOF tests\n";
-# These tests all take place at the start of the file
-try(    0,  4868,  4868);  # old=<x       , new=<x       ; old = new
-try(    0,   147,   118);  # old=<x       , new=<x       ; old > new
-try(    0,  8192,  8192);  # old=<x>      , new=<x       ; old = new
-try(    0,  8192,  4574);  # old=<x>      , new=<x       ; old > new
-try(    0, 11891,  1917);  # old=<x><x    , new=<x       ; old > new
-try(    0, 16384,  5155);  # old=<x><x>   , new=<x       ; old > new
-try(    0, 24576,  2953);  # old=<x><x><x>, new=<x       ; old > new
-try(    0,  8192,  8192);  # old=<x>      , new=<x>      ; old = new
-try(    0, 11083,  8192);  # old=<x><x    , new=<x>      ; old > new
-try(    0, 16384,  8192);  # old=<x><x>   , new=<x>      ; old > new
-try(    0, 24576,  8192);  # old=<x><x><x>, new=<x>      ; old > new
-try(    0, 14126, 14126);  # old=<x><x    , new=<x><x    ; old = new
-try(    0, 12002,  9034);  # old=<x><x    , new=<x><x    ; old > new
-try(    0, 16384, 13258);  # old=<x><x>   , new=<x><x    ; old > new
-try(    0, 24576, 14367);  # old=<x><x><x>, new=<x><x    ; old > new
-try(    0, 16384, 16384);  # old=<x><x>   , new=<x><x>   ; old = new
-try(    0, 24576, 16384);  # old=<x><x><x>, new=<x><x>   ; old > new
-try(    0, 24576, 24576);  # old=<x><x><x>, new=<x><x><x>; old = new
-try(    0,  6530,     0);  # old=<x       , new=0        ; old > new
-try(    0,  8192,     0);  # old=<x>      , new=0        ; old > new
-try(    0, 14707,     0);  # old=<x><x    , new=0        ; old > new
-try(    0, 16384,     0);  # old=<x><x>   , new=0        ; old > new
-try(    0, 24576,     0);  # old=<x><x><x>, new=0        ; old > new
-try(    0,     0,     0);  # old=0        , new=0        ; old = new
-
-print "# EOF tests 1\n";
-# These tests all take place at the end of the file
-$FLEN = 40960;  # Force the file to be exactly 40960 bytes long
-$oldfile = mkrand($FLEN);
-try(32768,  8192,  8192);  # old=<x>      , new=<x       ; old = new
-try(32768,  8192,  4026);  # old=<x>      , new=<x       ; old > new
-try(24576, 16384,  1917);  # old=<x><x>   , new=<x       ; old > new
-try(16384, 24576,  3818);  # old=<x><x><x>, new=<x       ; old > new
-try(32768,  8192,  8192);  # old=<x>      , new=<x>      ; old = new
-try(24576, 16384,  8192);  # old=<x><x>   , new=<x>      ; old > new
-try(16384, 24576,  8192);  # old=<x><x><x>, new=<x>      ; old > new
-try(24576, 16384, 12221);  # old=<x><x>   , new=<x><x    ; old > new
-try(16384, 24576, 15030);  # old=<x><x><x>, new=<x><x    ; old > new
-try(24576, 16384, 16384);  # old=<x><x>   , new=<x><x>   ; old = new
-try(16384, 24576, 16384);  # old=<x><x><x>, new=<x><x>   ; old > new
-try(16384, 24576, 24576);  # old=<x><x><x>, new=<x><x><x>; old = new
-try(35973,  4987,     0);  # old=x>       , new=0        ; old > new
-try(32768,  8192,     0);  # old=<x>      , new=0        ; old > new
-try(29932, 11028,     0);  # old=x><x>    , new=0        ; old > new
-try(24576, 16384,     0);  # old=<x><x>   , new=0        ; old > new
-try(16384, 24576,     0);  # old=<x><x><x>, new=0        ; old > new
-try(40960,     0,     0);  # old=0        , new=0        ; old = new
-
-print "# EOF tests 2\n";
-# These tests all take place at the end of the file
-$FLEN = 42000;  # Force the file to be exactly 42000 bytes long
-$oldfile = mkrand($FLEN);
-try(41683,   317,   317);  # old=x        , new=x        ; old = new
-try(41225,   775,   405);  # old=x        , new=x        ; old > new
-try(35709,  6291,   284);  # old=x><x     , new=x        ; old > new
-try(40960,  1040,  1040);  # old=<x       , new=<x       ; old = new
-try(40960,  1040,   378);  # old=<x       , new=<x       ; old > new
-try(32768,  9232,  5604);  # old=<x><x    , new=<x       ; old > new
-try(39994,  2006,   966);  # old=x><x     , new=x>       ; old > new
-try(36725,  5275,  5275);  # old=x><x     , new=x><x     ; old = new
-try(37990,  4010,  3199);  # old=x><x     , new=x><x     ; old > new
-try(32768,  9232,  8192);  # old=<x><x    , new=<x>      ; old > new
-try(32768,  9232,  9232);  # old=<x><x    , new=<x><x    ; old = new
-try(32768,  9232,  8795);  # old=<x><x    , new=<x><x    ; old > new
-try(41500,   500,     0);  # old=x        , new=0        ; old > new
-try(40960,  1040,     0);  # old=<x       , new=0        ; old > new
-try(35272,  6728,     0);  # old=x><x     , new=0        ; old > new
-try(32768,  9232,     0);  # old=<x><x    , new=0        ; old > new
-try(42000,     0,     0);  # old=0        , new=0        ; old = new
-
-# Now the REAL tests 
-# Make sure mtwrite can properly write sequences of several intervals
-# The intervals tested above were accumulated into @TRIES.
-# try_all_doubles() tries every possible sensible pair of those intervals.
-# try_all_triples() tries every possible sensible group of 
-#  tree intervals from the more restrictive set @BASE_TRIES.
-$FLEN = 40970;
-$oldfile = mkrand($FLEN);
-try_all_doubles();
-try_all_triples();
-
-sub mkrand {
-  my $len = shift;
-  srand $len;
-  my @c = ('a' .. 'z', 'A' .. 'Z', 0..9, $:);
-  my $d = "";
-  $d .= $c[rand @c] until length($d) >= $len;
-  substr($d, $len) = ""; # chop it off to the proper length
-  $d;
-}
-
-sub try {
-  push @TRIES, [@_] if @_ == 3;
-
-  open F, "> $file" or die "Couldn't open file $file: $!";
-  binmode F;
-  print F $oldfile;
-  close F;
-  die "wrong length!" unless -s $file == $FLEN;
-
-  my @mt_args; 
-  my $expected = $oldfile;
-  { my @a = @_;
-    my $c = "a";
-    while (@a) {
-      my ($s, $len, $newlen) = splice @a, -3;
-      my $newdata = $c++ x $newlen;
-      substr($expected, $s, $len, $newdata);
-      unshift @mt_args, $newdata, $s, $len;
-    }
-  }
-
-  my $o = tie my @lines, 'Tie::File', $file or die $!;
-  my $actual_return = $o->_mtwrite(@mt_args);
-  undef $o; untie @lines;
-
-  open F, "< $file" or die "Couldn't open file $file: $!";
-  binmode F;
-  my $actual;
-  { local $/;
-    $actual = <F>;
-  }
-  close F;
-
-  my ($alen, $xlen) = (length $actual, length $expected);
-  unless ($alen == $xlen) {
-    print "# try(@_) expected file length $xlen, actual $alen!\n";
-  }
-  print $actual eq $expected ? "ok $N\n" : "not ok $N\n";
-  $N++;
-
-#  if (! defined $actual_return && ! defined $expected_return) {
-#    print "ok $N\n";
-#  } elsif (! defined $actual_return || ! defined $expected_return) {
-#    print "not ok $N\n";
-#  } else {
-#    print $actual_return eq $expected_return ? "ok $N\n" : "not ok $N\n";
-#  }
-#  $N++;
-}
-
-sub try_all_doubles {
-  print "# Trying double regions.\n";
-  for my $a (@TRIES) {
-    next if $a->[0] + $a->[1] >= $FLEN;
-    next if $a->[0] + $a->[2] >= $FLEN;
-    for my $b (@TRIES) {
-      next if $b->[0] + $b->[1] >= $FLEN;
-      next if $b->[0] + $b->[2] >= $FLEN;
-
-      next if $b->[0] < $a->[0] + $a->[1]; # Overlapping regions
-      try(@$a, @$b);
-    }
-  }
-}
-
-sub try_all_triples {
-  print "# Trying triple regions.\n";
-  for my $a (@BASE_TRIES) {
-    next if $a->[0] + $a->[1] >= $FLEN;
-    next if $a->[0] + $a->[2] >= $FLEN;
-    for my $b (@BASE_TRIES) {
-      next if $b->[0] + $b->[1] >= $FLEN;
-      next if $b->[0] + $b->[2] >= $FLEN;
-
-      next if $b->[0] < $a->[0] + $a->[1]; # Overlapping regions
-
-      for my $c (@BASE_TRIES) {
-        next if $c->[0] + $c->[1] >= $FLEN;
-        next if $c->[0] + $c->[2] >= $FLEN;
-
-        next if $c->[0] < $b->[0] + $b->[1]; # Overlapping regions
-        try(@$a, @$b, @$c);
-      }
-    }
-  }
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/29_downcopy.t b/ext/Tie-File/t/29_downcopy.t
deleted file mode 100644
index d75806d5b2..0000000000
--- a/ext/Tie-File/t/29_downcopy.t
+++ /dev/null
@@ -1,363 +0,0 @@
-#!/usr/bin/perl
-#
-# Unit tests of _downcopy function
-#
-# _downcopy($self, $data, $pos, $len)
-# Write $data into a block of length $len at position $pos,
-# moving everything in the block forwards to make room.
-# Instead of writing the last length($data) bytes from the block
-# (because there isn't room for them any longer) return them.
-#
-#
-
-my $file = "tf$$.txt";
-
-print "1..718\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-$: = Tie::File::_default_recsep();
-
-my @subtests = qw(x <x x> x><x <x> <x><x x><x> <x><x> <x><x><x> 0);
-print "ok $N\n"; $N++;
-
-# (3-144) These were generated by 'gentests.pl' to cover all possible cases
-# (I hope)
-# Legend:
-#         x: data is entirely contained within one block
-#        x>: data runs from the middle to the end of the block
-#        <x: data runs from the start to the middle of the block
-#       <x>: data occupies precisely one block
-#      x><x: data overlaps one block boundary
-#     <x><x: data runs from the start of one block into the middle of the next
-#     x><x>: data runs from the middle of one block to the end of the next
-#    <x><x>: data occupies two blocks exactly
-# <x><x><x>: data occupies three blocks exactly
-#         0: data is null
-#
-# For each possible alignment of the old and new data, we investigate
-# up to three situations: old data is shorter, old and new data are the
-# same length, and new data is shorter.
-#
-# try($pos, $old, $new) means to run a test where the data starts at 
-# position $pos, the old data has length $old,
-# and the new data has length $new.
-try( 9659,  6635,  6691);  # old=x        , new=x        ; old < new
-try( 8605,  2394,  2394);  # old=x        , new=x        ; old = new
-try( 9768,  1361,   664);  # old=x        , new=x        ; old > new
-try( 9955,  6429,  6429);  # old=x>       , new=x        ; old = new
-try(10550,  5834,  4123);  # old=x>       , new=x        ; old > new
-try(14580,  6158,   851);  # old=x><x     , new=x        ; old > new
-try(13442, 11134,  1572);  # old=x><x>    , new=x        ; old > new
-try( 8394,     0,  5742);  # old=0        , new=x        ; old < new
-try( 8192,  2819,  6738);  # old=<x       , new=<x       ; old < new
-try( 8192,   514,   514);  # old=<x       , new=<x       ; old = new
-try( 8192,  2196,   858);  # old=<x       , new=<x       ; old > new
-try( 8192,  8192,  8192);  # old=<x>      , new=<x       ; old = new
-try( 8192,  8192,  1290);  # old=<x>      , new=<x       ; old > new
-try( 8192, 10575,  6644);  # old=<x><x    , new=<x       ; old > new
-try( 8192, 16384,  5616);  # old=<x><x>   , new=<x       ; old > new
-try( 8192, 24576,  6253);  # old=<x><x><x>, new=<x       ; old > new
-try( 8192,     0,  6870);  # old=0        , new=<x       ; old < new
-try( 8478,  6259,  7906);  # old=x        , new=x>       ; old < new
-try( 9965,  6419,  6419);  # old=x>       , new=x>       ; old = new
-try(16059,  6102,   325);  # old=x><x     , new=x>       ; old > new
-try( 9503, 15073,  6881);  # old=x><x>    , new=x>       ; old > new
-try( 9759,     0,  6625);  # old=0        , new=x>       ; old < new
-try( 8525,  2081,  8534);  # old=x        , new=x><x     ; old < new
-try(15550,   834,  1428);  # old=x>       , new=x><x     ; old < new
-try(14966,  1668,  3479);  # old=x><x     , new=x><x     ; old < new
-try(16316,  1605,  1605);  # old=x><x     , new=x><x     ; old = new
-try(16093,  4074,   993);  # old=x><x     , new=x><x     ; old > new
-try(14739,  9837,  9837);  # old=x><x>    , new=x><x     ; old = new
-try(14071, 10505,  7344);  # old=x><x>    , new=x><x     ; old > new
-try(12602,     0,  8354);  # old=0        , new=x><x     ; old < new
-try( 8192,  2767,  8192);  # old=<x       , new=<x>      ; old < new
-try( 8192,  8192,  8192);  # old=<x>      , new=<x>      ; old = new
-try( 8192, 14817,  8192);  # old=<x><x    , new=<x>      ; old > new
-try( 8192, 16384,  8192);  # old=<x><x>   , new=<x>      ; old > new
-try( 8192, 24576,  8192);  # old=<x><x><x>, new=<x>      ; old > new
-try( 8192,     0,  8192);  # old=0        , new=<x>      ; old < new
-try( 8192,  6532, 10882);  # old=<x       , new=<x><x    ; old < new
-try( 8192,  8192, 16044);  # old=<x>      , new=<x><x    ; old < new
-try( 8192,  9555, 11020);  # old=<x><x    , new=<x><x    ; old < new
-try( 8192,  9001,  9001);  # old=<x><x    , new=<x><x    ; old = new
-try( 8192, 11760, 10274);  # old=<x><x    , new=<x><x    ; old > new
-try( 8192, 16384, 10781);  # old=<x><x>   , new=<x><x    ; old > new
-try( 8192, 24576,  9284);  # old=<x><x><x>, new=<x><x    ; old > new
-try( 8192,     0, 12488);  # old=0        , new=<x><x    ; old < new
-try( 8222,  6385, 16354);  # old=x        , new=x><x>    ; old < new
-try(13500,  2884, 11076);  # old=x>       , new=x><x>    ; old < new
-try(14069,  4334, 10507);  # old=x><x     , new=x><x>    ; old < new
-try(14761,  9815,  9815);  # old=x><x>    , new=x><x>    ; old = new
-try(10469,     0, 14107);  # old=0        , new=x><x>    ; old < new
-try( 8192,  4181, 16384);  # old=<x       , new=<x><x>   ; old < new
-try( 8192,  8192, 16384);  # old=<x>      , new=<x><x>   ; old < new
-try( 8192, 12087, 16384);  # old=<x><x    , new=<x><x>   ; old < new
-try( 8192, 16384, 16384);  # old=<x><x>   , new=<x><x>   ; old = new
-try( 8192, 24576, 16384);  # old=<x><x><x>, new=<x><x>   ; old > new
-try( 8192,     0, 16384);  # old=0        , new=<x><x>   ; old < new
-try( 8192,  4968, 24576);  # old=<x       , new=<x><x><x>; old < new
-try( 8192,  8192, 24576);  # old=<x>      , new=<x><x><x>; old < new
-try( 8192, 14163, 24576);  # old=<x><x    , new=<x><x><x>; old < new
-try( 8192, 16384, 24576);  # old=<x><x>   , new=<x><x><x>; old < new
-try( 8192, 24576, 24576);  # old=<x><x><x>, new=<x><x><x>; old = new
-try( 8192,     0, 24576);  # old=0        , new=<x><x><x>; old < new
-try( 8771,   776,     0);  # old=x        , new=0        ; old > new
-try( 8192,  2813,     0);  # old=<x       , new=0        ; old > new
-try(13945,  2439,     0);  # old=x>       , new=0        ; old > new
-try(14493,  6090,     0);  # old=x><x     , new=0        ; old > new
-try( 8192,  8192,     0);  # old=<x>      , new=0        ; old > new
-try( 8192, 10030,     0);  # old=<x><x    , new=0        ; old > new
-try(14983,  9593,     0);  # old=x><x>    , new=0        ; old > new
-try( 8192, 16384,     0);  # old=<x><x>   , new=0        ; old > new
-try( 8192, 24576,     0);  # old=<x><x><x>, new=0        ; old > new
-try(10489,     0,     0);  # old=0        , new=0        ; old = new
-
-# (142-223)
-# These tests all take place at the start of the file
-try(    0,   771,  1593);  # old=<x       , new=<x       ; old < new
-try(    0,  4868,  4868);  # old=<x       , new=<x       ; old = new
-try(    0,   147,   118);  # old=<x       , new=<x       ; old > new
-try(    0,  8192,  8192);  # old=<x>      , new=<x       ; old = new
-try(    0,  8192,  4574);  # old=<x>      , new=<x       ; old > new
-try(    0, 11891,  1917);  # old=<x><x    , new=<x       ; old > new
-try(    0, 16384,  5155);  # old=<x><x>   , new=<x       ; old > new
-try(    0, 24576,  2953);  # old=<x><x><x>, new=<x       ; old > new
-try(    0,     0,  1317);  # old=0        , new=<x       ; old < new
-try(    0,  5609,  8192);  # old=<x       , new=<x>      ; old < new
-try(    0,  8192,  8192);  # old=<x>      , new=<x>      ; old = new
-try(    0, 11083,  8192);  # old=<x><x    , new=<x>      ; old > new
-try(    0, 16384,  8192);  # old=<x><x>   , new=<x>      ; old > new
-try(    0, 24576,  8192);  # old=<x><x><x>, new=<x>      ; old > new
-try(    0,     0,  8192);  # old=0        , new=<x>      ; old < new
-try(    0,  6265,  9991);  # old=<x       , new=<x><x    ; old < new
-try(    0,  8192, 16119);  # old=<x>      , new=<x><x    ; old < new
-try(    0, 10218, 11888);  # old=<x><x    , new=<x><x    ; old < new
-try(    0, 14126, 14126);  # old=<x><x    , new=<x><x    ; old = new
-try(    0, 12002,  9034);  # old=<x><x    , new=<x><x    ; old > new
-try(    0, 16384, 13258);  # old=<x><x>   , new=<x><x    ; old > new
-try(    0, 24576, 14367);  # old=<x><x><x>, new=<x><x    ; old > new
-try(    0,     0, 10881);  # old=0        , new=<x><x    ; old < new
-try(    0,  6448, 16384);  # old=<x       , new=<x><x>   ; old < new
-try(    0,  8192, 16384);  # old=<x>      , new=<x><x>   ; old < new
-try(    0, 15082, 16384);  # old=<x><x    , new=<x><x>   ; old < new
-try(    0, 16384, 16384);  # old=<x><x>   , new=<x><x>   ; old = new
-try(    0, 24576, 16384);  # old=<x><x><x>, new=<x><x>   ; old > new
-try(    0,     0, 16384);  # old=0        , new=<x><x>   ; old < new
-try(    0,  2421, 24576);  # old=<x       , new=<x><x><x>; old < new
-try(    0,  8192, 24576);  # old=<x>      , new=<x><x><x>; old < new
-try(    0, 11655, 24576);  # old=<x><x    , new=<x><x><x>; old < new
-try(    0, 16384, 24576);  # old=<x><x>   , new=<x><x><x>; old < new
-try(    0, 24576, 24576);  # old=<x><x><x>, new=<x><x><x>; old = new
-try(    0,     0, 24576);  # old=0        , new=<x><x><x>; old < new
-try(    0,  6530,     0);  # old=<x       , new=0        ; old > new
-try(    0,  8192,     0);  # old=<x>      , new=0        ; old > new
-try(    0, 14707,     0);  # old=<x><x    , new=0        ; old > new
-try(    0, 16384,     0);  # old=<x><x>   , new=0        ; old > new
-try(    0, 24576,     0);  # old=<x><x><x>, new=0        ; old > new
-try(    0,     0,     0);  # old=0        , new=0        ; old = new
-
-# (224-277)
-# These tests all take place at the end of the file
-$FLEN = 40960;  # Force the file to be exactly 40960 bytes long
-try(32768,  8192,  8192);  # old=<x>      , new=<x       ; old = new
-try(32768,  8192,  4026);  # old=<x>      , new=<x       ; old > new
-try(24576, 16384,  1917);  # old=<x><x>   , new=<x       ; old > new
-try(16384, 24576,  3818);  # old=<x><x><x>, new=<x       ; old > new
-try(40960,     0,  2779);  # old=0        , new=<x       ; old < new
-try(32768,  8192,  8192);  # old=<x>      , new=<x>      ; old = new
-try(24576, 16384,  8192);  # old=<x><x>   , new=<x>      ; old > new
-try(16384, 24576,  8192);  # old=<x><x><x>, new=<x>      ; old > new
-try(40960,     0,  8192);  # old=0        , new=<x>      ; old < new
-try(32768,  8192, 10724);  # old=<x>      , new=<x><x    ; old < new
-try(24576, 16384, 12221);  # old=<x><x>   , new=<x><x    ; old > new
-try(16384, 24576, 15030);  # old=<x><x><x>, new=<x><x    ; old > new
-try(40960,     0, 11752);  # old=0        , new=<x><x    ; old < new
-try(32768,  8192, 16384);  # old=<x>      , new=<x><x>   ; old < new
-try(24576, 16384, 16384);  # old=<x><x>   , new=<x><x>   ; old = new
-try(16384, 24576, 16384);  # old=<x><x><x>, new=<x><x>   ; old > new
-try(40960,     0, 16384);  # old=0        , new=<x><x>   ; old < new
-try(32768,  8192, 24576);  # old=<x>      , new=<x><x><x>; old < new
-try(24576, 16384, 24576);  # old=<x><x>   , new=<x><x><x>; old < new
-try(16384, 24576, 24576);  # old=<x><x><x>, new=<x><x><x>; old = new
-try(40960,     0, 24576);  # old=0        , new=<x><x><x>; old < new
-try(35973,  4987,     0);  # old=x>       , new=0        ; old > new
-try(32768,  8192,     0);  # old=<x>      , new=0        ; old > new
-try(29932, 11028,     0);  # old=x><x>    , new=0        ; old > new
-try(24576, 16384,     0);  # old=<x><x>   , new=0        ; old > new
-try(16384, 24576,     0);  # old=<x><x><x>, new=0        ; old > new
-try(40960,     0,     0);  # old=0        , new=0        ; old = new
-
-# (278-357)
-# These tests all take place at the end of the file
-$FLEN = 42000;  # Force the file to be exactly 42000 bytes long
-try(41275,   725,  4059);  # old=x        , new=x        ; old < new
-try(41683,   317,   317);  # old=x        , new=x        ; old = new
-try(41225,   775,   405);  # old=x        , new=x        ; old > new
-try(35709,  6291,   284);  # old=x><x     , new=x        ; old > new
-try(42000,     0,  2434);  # old=0        , new=x        ; old < new
-try(40960,  1040,  1608);  # old=<x       , new=<x       ; old < new
-try(40960,  1040,  1040);  # old=<x       , new=<x       ; old = new
-try(40960,  1040,   378);  # old=<x       , new=<x       ; old > new
-try(32768,  9232,  5604);  # old=<x><x    , new=<x       ; old > new
-try(42000,     0,  6637);  # old=0        , new=<x       ; old < new
-try(41022,   978,  8130);  # old=x        , new=x>       ; old < new
-try(39994,  2006,   966);  # old=x><x     , new=x>       ; old > new
-try(42000,     0,  7152);  # old=0        , new=x>       ; old < new
-try(41613,   387, 10601);  # old=x        , new=x><x     ; old < new
-try(38460,  3540,  3938);  # old=x><x     , new=x><x     ; old < new
-try(36725,  5275,  5275);  # old=x><x     , new=x><x     ; old = new
-try(37990,  4010,  3199);  # old=x><x     , new=x><x     ; old > new
-try(42000,     0,  9189);  # old=0        , new=x><x     ; old < new
-try(40960,  1040,  8192);  # old=<x       , new=<x>      ; old < new
-try(32768,  9232,  8192);  # old=<x><x    , new=<x>      ; old > new
-try(42000,     0,  8192);  # old=0        , new=<x>      ; old < new
-try(40960,  1040, 11778);  # old=<x       , new=<x><x    ; old < new
-try(32768,  9232, 13792);  # old=<x><x    , new=<x><x    ; old < new
-try(32768,  9232,  9232);  # old=<x><x    , new=<x><x    ; old = new
-try(32768,  9232,  8795);  # old=<x><x    , new=<x><x    ; old > new
-try(42000,     0,  8578);  # old=0        , new=<x><x    ; old < new
-try(41531,   469, 15813);  # old=x        , new=x><x>    ; old < new
-try(39618,  2382,  9534);  # old=x><x     , new=x><x>    ; old < new
-try(42000,     0, 15344);  # old=0        , new=x><x>    ; old < new
-try(40960,  1040, 16384);  # old=<x       , new=<x><x>   ; old < new
-try(32768,  9232, 16384);  # old=<x><x    , new=<x><x>   ; old < new
-try(42000,     0, 16384);  # old=0        , new=<x><x>   ; old < new
-try(40960,  1040, 24576);  # old=<x       , new=<x><x><x>; old < new
-try(32768,  9232, 24576);  # old=<x><x    , new=<x><x><x>; old < new
-try(42000,     0, 24576);  # old=0        , new=<x><x><x>; old < new
-try(41500,   500,     0);  # old=x        , new=0        ; old > new
-try(40960,  1040,     0);  # old=<x       , new=0        ; old > new
-try(35272,  6728,     0);  # old=x><x     , new=0        ; old > new
-try(32768,  9232,     0);  # old=<x><x    , new=0        ; old > new
-try(42000,     0,     0);  # old=0        , new=0        ; old = new
-
-sub try {
-  my ($pos, $len, $newlen) = @_;
-  open F, "> $file" or die "Couldn't open file $file: $!";
-  binmode F;
-
-  # The record has exactly 17 characters.  This will help ensure that
-  # even if _downcoopy screws up, the data doesn't coincidentally
-  # look good because the remainder accidentally lines up.
-  my $d = substr("0123456789abcdef$:", -17);
-  my $recs = defined($FLEN) ?
-    int($FLEN/length($d))+1 : # enough to make up at least $FLEN
-    int(8192*5/length($d))+1; # at least 5 blocks' worth
-  my $oldfile = $d x $recs;
-  my $flen = defined($FLEN) ? $FLEN : $recs * 17;
-  substr($oldfile, $FLEN) = "" if defined $FLEN;  # truncate
-  print F $oldfile;
-  close F;
-
-  die "wrong length!" unless -s $file == $flen;
-
-  my $newdata = "-" x $newlen;
-  my $expected = $oldfile;
-  my $old = defined $len ? substr($expected, $pos, $len) 
-                         : substr($expected, $pos);
-  $old = "$newdata$old";
-  my $x_retval;
-  if (defined $len) {
-    substr($expected, $pos, $len, substr($old, 0, $len, ""));
-    $x_retval = $old;
-  } else {
-    substr($expected, $pos) = $old;
-    $x_retval = "";
-  }
-
-  my $o = tie my @lines, 'Tie::File', $file or die $!;
-  local $SIG{ALRM} = sub { die "Alarm clock" };
-  my $a_retval = eval { alarm(5) unless $^P; $o->_downcopy($newdata, $pos, $len) };
-  my $err = $@;
-  undef $o; untie @lines; alarm(0);
-  if ($err) {
-    if ($err =~ /^Alarm clock/) {
-      print "# Timeout\n";
-      print "not ok $N\n"; $N++;
-      print "not ok $N\n"; $N++;
-      return;
-    } else {
-      $@ = $err;
-      die;
-    }
-  }
-
-  open F, "< $file" or die "Couldn't open file $file: $!";
-  binmode F;
-  my $actual;
-  { local $/;
-    $actual = <F>;
-  }
-  close F;
-
-  my ($alen, $xlen) = (length $actual, length $expected);
-  unless ($alen == $xlen) {
-    my @ARGS = @_;
-    for (@ARGS) { $_ = "UNDEF" unless defined }
-    print "# try(@ARGS) expected file length $xlen, actual $alen!\n";
-  }
-  print $actual eq $expected ? "ok $N\n" : "not ok $N\n";
-  $N++;
-  print $a_retval eq $x_retval ? "ok $N\n" : "not ok $N\n";
-  $N++;
-
-  if (defined $len) {
-    try($pos, undef, $newlen);
-  }
-}
-
-
-
-use POSIX 'SEEK_SET';
-sub check_contents {
-  my @c = @_;
-  my $x = join $:, @c, '';
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-#  my $open = open FH, "< $file";
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix($a, $x);
-    print "not ok $N\n# expected <$x>, got <$a>\n";
-  }
-  $N++;
-
-  # now check FETCH:
-  my $good = 1;
-  my $msg;
-  for (0.. $#c) {
-    my $aa = $a[$_];
-    unless ($aa eq "$c[$_]$:") {
-      $msg = "expected <$c[$_]$:>, got <$aa>";
-      ctrlfix($msg);
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N # $msg\n";
-  $N++;
-
-  print $o->_check_integrity($file, $ENV{INTEGRITY}) 
-      ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
diff --git a/ext/Tie-File/t/29a_upcopy.t b/ext/Tie-File/t/29a_upcopy.t
deleted file mode 100644
index 1130615f37..0000000000
--- a/ext/Tie-File/t/29a_upcopy.t
+++ /dev/null
@@ -1,211 +0,0 @@
-#!/usr/bin/perl
-#
-# Unit tests of _upcopy function
-#
-# _upcopy($self, $source, $dest, $len)
-#
-# Take a block of data of leength $len at $source and copy it
-# to $dest, which must be <= $source but which need not be <= $source - $len
-# (That is, this will only copy a block to a position earlier in the file,
-# but the source and destination regions may overlap.)
-
-
-my $file = "tf$$.txt";
-
-print "1..55\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-$: = Tie::File::_default_recsep();
-
-my @subtests = qw(x <x x> x><x <x> <x><x x><x> <x><x> <x><x><x> 0);
-
-$FLEN = 40970;  # 2410 records of 17 chars each
-
-# (2-7) Trivial non-moves at start of file
-try(0, 0, 0);
-try(0, 0, 10);
-try(0, 0, 100);
-try(0, 0, 1000);
-try(0, 0, 10000);
-try(0, 0, 20000);
-
-# (8-13) Trivial non-moves in middle of file
-try(100, 100, 0);
-try(100, 100, 10);
-try(100, 100, 100);
-try(100, 100, 1000);
-try(100, 100, 10000);
-try(100, 100, 20000);
-
-# (14) Trivial non-move at end of file
-try($FLEN, $FLEN, 0);
-
-# (15-17) Trivial non-move of tail of file
-try(0, 0, undef);
-try(100, 100, undef);
-try($FLEN, $FLEN, undef);
-
-# (18-24) Moves to start of file
-try(100, 0, 0);
-try(100, 0, 10);
-try(100, 0, 100);
-try(100, 0, 1000);
-try(100, 0, 10000);
-try(100, 0, 20000);
-try(100, 0, undef);
-
-# (25-31) Moves in middle of file
-try(200, 100, 0);
-try(200, 100, 10);
-try(200, 100, 100);
-try(200, 100, 1000);
-try(200, 100, 10000);
-try(200, 100, 20000);
-try(200, 100, undef);
-
-# (32-43) Moves from end of file
-try($FLEN, 10000, 0);
-try($FLEN-10, 10000, 10);
-try($FLEN-100, 10000, 100);
-try($FLEN-1000, 200, 1000);
-try($FLEN-10000, 200, 10000);
-try($FLEN-20000, 200, 20000);
-try($FLEN, 10000, undef);
-try($FLEN-10, 10000, undef);
-try($FLEN-100, 10000, undef);
-try($FLEN-1000, 200, undef);
-try($FLEN-10000, 200, undef);
-try($FLEN-20000, 200, undef);
-
-$FLEN = 40960;
-
-# (44-55) Moves from end of file when file ends on a block boundary
-try($FLEN, 10000, 0);
-try($FLEN-10, 10000, 10);
-try($FLEN-100, 10000, 100);
-try($FLEN-1000, 200, 1000);
-try($FLEN-10000, 200, 10000);
-try($FLEN-20000, 200, 20000);
-try($FLEN, 10000, undef);
-try($FLEN-10, 10000, undef);
-try($FLEN-100, 10000, undef);
-try($FLEN-1000, 200, undef);
-try($FLEN-10000, 200, undef);
-try($FLEN-20000, 200, undef);
-
-sub try {
-  my ($src, $dst, $len) = @_;
-  open F, "> $file" or die "Couldn't open file $file: $!";
-  binmode F;
-
-  # The record has exactly 17 characters.  This will help ensure that
-  # even if _upcopy screws up, the data doesn't coincidentally
-  # look good because the remainder accidentally lines up.
-  my $d = substr("0123456789abcdef$:", -17);
-  my $recs = defined($FLEN) ?
-    int($FLEN/length($d))+1 : # enough to make up at least $FLEN
-    int(8192*5/length($d))+1; # at least 5 blocks' worth
-  my $oldfile = $d x $recs;
-  my $flen = defined($FLEN) ? $FLEN : $recs * 17;
-  substr($oldfile, $FLEN) = "" if defined $FLEN;  # truncate
-  print F $oldfile;
-  close F;
-
-  die "wrong length!" unless -s $file == $flen;
-
-  # If len is specified, use that.  If it's undef,
-  # then behave *as if* we had specified the whole rest of the file
-  my $expected = $oldfile;
-  if (defined $len) {
-    substr($expected, $dst, $len) = substr($expected, $src, $len);
-  } else {
-    substr($expected, $dst) = substr($expected, $src);
-  }
-
-  my $o = tie my @lines, 'Tie::File', $file or die $!;
-  local $SIG{ALRM} = sub { die "Alarm clock" };
-  my $a_retval = eval { alarm(5) unless $^P; $o->_upcopy($src, $dst, $len) };
-  my $err = $@;
-  undef $o; untie @lines; alarm(0);
-  if ($err) {
-    if ($err =~ /^Alarm clock/) {
-      print "# Timeout\n";
-      print "not ok $N\n"; $N++;
-      return;
-    } else {
-      $@ = $err;
-      die;
-    }
-  }
-
-  open F, "< $file" or die "Couldn't open file $file: $!";
-  binmode F;
-  my $actual;
-  { local $/;
-    $actual = <F>;
-  }
-  close F;
-
-  my ($alen, $xlen) = (length $actual, length $expected);
-  unless ($alen == $xlen) {
-    print "# try(@_) expected file length $xlen, actual $alen!\n";
-  }
-  print $actual eq $expected ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-
-
-use POSIX 'SEEK_SET';
-sub check_contents {
-  my @c = @_;
-  my $x = join $:, @c, '';
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-#  my $open = open FH, "< $file";
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix($a, $x);
-    print "not ok $N\n# expected <$x>, got <$a>\n";
-  }
-  $N++;
-
-  # now check FETCH:
-  my $good = 1;
-  my $msg;
-  for (0.. $#c) {
-    my $aa = $a[$_];
-    unless ($aa eq "$c[$_]$:") {
-      $msg = "expected <$c[$_]$:>, got <$aa>";
-      ctrlfix($msg);
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N # $msg\n";
-  $N++;
-
-  print $o->_check_integrity($file, $ENV{INTEGRITY}) 
-      ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/30_defer.t b/ext/Tie-File/t/30_defer.t
deleted file mode 100644
index 063b3a7090..0000000000
--- a/ext/Tie-File/t/30_defer.t
+++ /dev/null
@@ -1,328 +0,0 @@
-#!/usr/bin/perl
-#
-# Check ->defer and ->flush methods
-#
-# This is the old version, which you used in the past when
-# there was a defer buffer separate from the read cache.  
-# There isn't any longer.
-#
-
-use POSIX 'SEEK_SET';
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-my $data = "rec0$:rec1$:rec2$:";
-my ($o, $n);
-
-print "1..79\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-open F, "> $file" or die $!;
-binmode F;
-print F $data;
-close F;
-$o = tie @a, 'Tie::File', $file;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# (3-6) Deferred storage
-$o->defer;
-$a[3] = "rec3";
-check_contents($data);          # nothing written yet
-$a[4] = "rec4";
-check_contents($data);          # nothing written yet
-
-# (7-8) Flush
-$o->flush;
-check_contents($data . "rec3$:rec4$:");          # now it's written
-
-# (9-12) Deferred writing disabled?
-$a[3] = "rec9";
-check_contents("${data}rec9$:rec4$:");
-$a[4] = "rec8";
-check_contents("${data}rec9$:rec8$:");
-
-# (13-18) Now let's try two batches of records
-$#a = 2;
-$o->defer;
-$a[0] = "record0";
-check_contents($data);          # nothing written yet
-$a[2] = "record2";
-check_contents($data);          # nothing written yet
-$o->flush;
-check_contents("record0$:rec1$:record2$:");
-
-# (19-22) Deferred writing past the end of the file
-$o->defer;
-$a[4] = "record4";
-check_contents("record0$:rec1$:record2$:");
-$o->flush;
-check_contents("record0$:rec1$:record2$:$:record4$:");
-
-
-# (23-26) Now two long batches
-$o->defer;
-for (0..2, 4..6) {
-  $a[$_] = "r$_";
-}
-check_contents("record0$:rec1$:record2$:$:record4$:");
-$o->flush;
-check_contents(join $:, "r0".."r2", "", "r4".."r6", "");
-
-# (27-30) Now let's make sure that discarded writes are really discarded
-# We have a 2Mib buffer here, so we can be sure that we aren't accidentally
-# filling it up
-$o->defer;
-for (0, 3, 7) {
-  $a[$_] = "discarded$_";
-}
-check_contents(join $:, "r0".."r2", "", "r4".."r6", "");
-$o->discard;
-check_contents(join $:, "r0".."r2", "", "r4".."r6", "");
-
-################################################################
-#
-# Now we're going to test the results of a small memory limit
-#
-# 
-undef $o;  untie @a;
-$data = join "$:", map("record$_", 0..7), "";  # records are 8 or 9 bytes long
-open F, "> $file" or die $!;
-binmode F;
-print F $data;
-close F;
-
-# Limit cache+buffer size to 47 bytes 
-my $MAX = 47;
-#  -- that's enough space for 5 records, but not 6, on both \n and \r\n systems
-my $BUF = 20;
-#  -- that's enough space for 2 records, but not 3, on both \n and \r\n systems
-$o = tie @a, 'Tie::File', $file, memory => $MAX, dw_size => $BUF;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# (31-32) Fill up the read cache
-my @z;
-@z = @a;                        
-# the cache now contains records 3,4,5,6,7.
-check_caches({map(($_ => "record$_$:"), 3..7)}, 
-             {});
-
-# (33-44) See if overloading the defer starts by flushing the read cache
-# and then flushes out the defer
-$o->defer;
-$a[0] = "recordA";              # That should flush record 3 from the cache
-check_caches({map(($_ => "record$_$:"), 4..7)}, 
-             {0 => "recordA$:"});
-check_contents($data);
-
-$a[1] = "recordB";              # That should flush record 4 from the cache
-check_caches({map(($_ => "record$_$:"), 5..7)}, 
-             {0 => "recordA$:",
-              1 => "recordB$:"});
-check_contents($data);
-
-$a[2] = "recordC";              # That should flush the whole darn defer
-# This shouldn't change the cache contents
-check_caches({map(($_ => "record$_$:"), 5..7)}, 
-             {});               # URRRP
-check_contents(join("$:", qw(recordA recordB recordC 
-                             record3 record4 record5 record6 record7)) . "$:");
-
-$a[3] = "recordD";         # even though we flushed, deferring is STILL ENABLED
-check_caches({map(($_ => "record$_$:"), 5..7)},
-             {3 => "recordD$:"}); 
-check_contents(join("$:", qw(recordA recordB recordC 
-                             record3 record4 record5 record6 record7)) . "$:");
-
-# Check readcache-deferbuffer interactions
-
-# (45-47) This should remove outdated data from the read cache
-$a[5] = "recordE";
-check_caches({6 => "record6$:", 7 => "record7$:"},
-             {3 => "recordD$:", 5 => "recordE$:"}); 
-check_contents(join("$:", qw(recordA recordB recordC 
-                             record3 record4 record5 record6 record7)) . "$:");
-
-# (48-51) This should read back out of the defer buffer
-# without adding anything to the read cache
-my $z;
-$z = $a[5];
-print $z eq "recordE" ? "ok $N\n" : "not ok $N\n";  $N++;
-check_caches({6 => "record6$:", 7 => "record7$:"},
-             {3 => "recordD$:", 5 => "recordE$:"}); 
-check_contents(join("$:", qw(recordA recordB recordC 
-                             record3 record4 record5 record6 record7)) . "$:");
-
-# (52-55) This should repopulate the read cache with a new record
-$z = $a[0];
-print $z eq "recordA" ? "ok $N\n" : "not ok $N\n";  $N++;
-check_caches({0 => "recordA$:", 6 => "record6$:", 7 => "record7$:"},
-             {3 => "recordD$:", 5 => "recordE$:"}); 
-check_contents(join("$:", qw(recordA recordB recordC 
-                             record3 record4 record5 record6 record7)) . "$:");
-
-# (56-59) This should flush the LRU record from the read cache
-$z = $a[4];
-print $z eq "record4" ? "ok $N\n" : "not ok $N\n";  $N++;
-check_caches({7 => "record7$:", 0 => "recordA$:", 4 => "record4$:"},
-             {3 => "recordD$:", 5 => "recordE$:"}); 
-check_contents(join("$:", qw(recordA recordB recordC 
-                             record3 record4 record5 record6 record7)) . "$:");
-
-# (60-63) This should FLUSH the deferred buffer
-$z = splice @a, 3, 1, "recordZ";
-print $z eq "recordD" ? "ok $N\n" : "not ok $N\n";  $N++;
-check_caches({7 => "record7$:", 0 => "recordA$:", 4 => "record4$:", 3 => "recordZ$:"},
-             {}); 
-check_contents(join("$:", qw(recordA recordB recordC 
-                             recordZ record4 recordE record6 record7)) . "$:");
-
-# (64-66) We should STILL be in deferred writing mode
-$a[5] = "recordX";
-check_caches({7 => "record7$:", 0 => "recordA$:", 4 => "record4$:", 3 => "recordZ$:"},
-             {5 => "recordX$:"}); 
-check_contents(join("$:", qw(recordA recordB recordC 
-                             recordZ record4 recordE record6 record7)) . "$:");
-
-# Fill up the defer buffer again
-$a[4] = "recordP";
-# (67-69) This should OVERWRITE the existing deferred record 
-# and NOT flush the buffer
-$a[5] = "recordQ";   
-check_caches({7 => "record7$:", 0 => "recordA$:", 3 => "recordZ$:"},
-             {5 => "recordQ$:", 4 => "recordP$:"}); 
-check_contents(join("$:", qw(recordA recordB recordC 
-                             recordZ record4 recordE record6 record7)) . "$:");
-
-# (70-72) Discard should just dump the whole deferbuffer
-$o->discard;
-check_caches({7 => "record7$:", 0 => "recordA$:", 3 => "recordZ$:"},
-             {}); 
-check_contents(join("$:", qw(recordA recordB recordC 
-                             recordZ record4 recordE record6 record7)) . "$:");
-
-# (73-75) NOW we are out of deferred writing mode
-$a[0] = "recordF";
-check_caches({7 => "record7$:", 0 => "recordF$:", 3 => "recordZ$:"},
-             {}); 
-check_contents(join("$:", qw(recordF recordB recordC
-                             recordZ record4 recordE record6 record7)) . "$:");
-
-# (76-79) Last call--untying the array should flush the deferbuffer
-$o->defer;
-$a[0] = "flushed";
-check_caches({7 => "record7$:",                   3 => "recordZ$:"},
-             {0 => "flushed$:" }); 
-check_contents(join("$:", qw(recordF recordB recordC
-                             recordZ record4 recordE record6 record7)) . "$:");
-undef $o;
-untie @a;
-# (79) We can't use check_contents any more, because the object is dead
-open F, "< $file" or die;
-binmode F;
-{ local $/ ; $z = <F> }
-close F;
-my $x = join("$:", qw(flushed recordB recordC
-                      recordZ record4 recordE record6 record7)) . "$:";
-if ($z eq $x) {
-  print "ok $N\n";
-} else {
-  my $msg = ctrlfix("expected <$x>, got <$z>");
-  print "not ok $N \# $msg\n";
-}
-$N++;
-
-################################################################
-
-
-sub check_caches {
-  my ($xcache, $xdefer) = @_;
-
-#  my $integrity = $o->_check_integrity($file, $ENV{INTEGRITY});
-#  print $integrity ? "ok $N\n" : "not ok $N\n";
-#  $N++;
-
-  my $good = 1;
-
-  # Copy the contents of the cache into a regular hash
-  my %cache;
-  for my $k ($o->{cache}->ckeys) {
-    $cache{$k} = $o->{cache}->_produce($k);
-  }
-
-  $good &&= hash_equal(\%cache, $xcache, "true cache", "expected cache");
-  $good &&= hash_equal($o->{deferred}, $xdefer, "true defer", "expected defer");
-  print $good ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-sub hash_equal {
-  my ($a, $b, $ha, $hb) = @_;
-  $ha = 'first hash'  unless defined $ha;
-  $hb = 'second hash' unless defined $hb;
-
-  my $good = 1;
-  my %b_seen;
-
-  for my $k (keys %$a) {
-    if (! exists $b->{$k}) {
-      print ctrlfix("# Key $k is in $ha but not $hb"), "\n";
-      $good = 0;
-    } elsif ($b->{$k} ne $a->{$k}) {
-      print ctrlfix("# Key $k is <$a->{$k}> in $ha but <$b->{$k}> in $hb"), "\n";
-      $b_seen{$k} = 1;
-      $good = 0;
-    } else {
-      $b_seen{$k} = 1;
-    }
-  }
-
-  for my $k (keys %$b) {
-    unless ($b_seen{$k}) {
-      print ctrlfix("# Key $k is in $hb but not $ha"), "\n";
-      $good = 0;
-    }
-  }
-
-  $good;
-}
-
-
-sub check_contents {
-  my $x = shift;
-
-  my $integrity = $o->_check_integrity($file, $ENV{INTEGRITY});
-  print $integrity ? "ok $N\n" : "not ok $N\n";
-  $N++;
-
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    my $msg = ctrlfix("# expected <$x>, got <$a>");
-    print "not ok $N\n$msg\n";
-  }
-  $N++;
-}
-
-sub ctrlfix {
-  local $_ = shift;
-  s/\n/\\n/g;
-  s/\r/\\r/g;
-  $_;
-}
-
-END {
-  undef $o;
-  untie @a if tied @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/31_autodefer.t b/ext/Tie-File/t/31_autodefer.t
deleted file mode 100644
index ea929a4097..0000000000
--- a/ext/Tie-File/t/31_autodefer.t
+++ /dev/null
@@ -1,182 +0,0 @@
-#!/usr/bin/perl
-#
-# Check behavior of 'autodefer' feature
-# Mostly this isn't implemented yet
-# This file is primarily here to make sure that the promised ->autodefer
-# method doesn't croak.
-#
-
-use POSIX 'SEEK_SET';
-
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-my $data = "rec0$:rec1$:rec2$:";
-my ($o, $n, @a);
-
-print "1..65\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-open F, "> $file" or die $!;
-binmode F;
-print F $data;
-close F;
-$o = tie @a, 'Tie::File', $file;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# I am an undocumented feature
-$o->{autodefer_filelen_threshhold} = 0;
-# Normally autodeferring only works on large files.  This disables that.
-
-# (3-22) Deferred storage
-$a[3] = "rec3";
-check_autodeferring('OFF');
-$a[4] = "rec4";
-check_autodeferring('OFF');
-$a[5] = "rec5";
-check_autodeferring('ON');
-check_contents($data . "rec3$:rec4$:"); # only the first two were written
-$a[6] = "rec6";
-check_autodeferring('ON');
-check_contents($data . "rec3$:rec4$:"); # still nothing written
-$a[7] = "rec7";
-check_autodeferring('ON');
-check_contents($data . "rec3$:rec4$:"); # still nothing written
-$a[0] = "recX";
-check_autodeferring('OFF');
-check_contents("recX$:rec1$:rec2$:rec3$:rec4$:rec5$:rec6$:rec7$:");
-$a[1] = "recY";
-check_autodeferring('OFF');
-check_contents("recX$:recY$:rec2$:rec3$:rec4$:rec5$:rec6$:rec7$:");
-$a[2] = "recZ";                 # it kicks in here
-check_autodeferring('ON');
-check_contents("recX$:recY$:rec2$:rec3$:rec4$:rec5$:rec6$:rec7$:");
-
-# (23-26) Explicitly enabling deferred writing deactivates autodeferring
-$o->defer;
-check_autodeferring('OFF');
-check_contents("recX$:recY$:recZ$:rec3$:rec4$:rec5$:rec6$:rec7$:");
-$o->discard;
-check_autodeferring('OFF');
-
-# (27-32) Now let's try the CLEAR special case
-@a = ("r0" .. "r4");
-check_autodeferring('ON');
-# The file was extended to the right length, but nothing was actually written.
-check_contents("$:$:$:$:$:");
-$a[2] = "fish";
-check_autodeferring('OFF');
-check_contents("r0$:r1$:fish$:r3$:r4$:");
-
-# (33-47) Now let's try the originally intended application:  a 'for' loop.
-my $it = 0;
-for (@a) {
-  $_ = "##$_";
-  if ($it == 0) {
-    check_autodeferring('OFF');
-    check_contents("##r0$:r1$:fish$:r3$:r4$:");
-  } elsif ($it == 1) {
-    check_autodeferring('OFF');
-    check_contents("##r0$:##r1$:fish$:r3$:r4$:");
-  } else {
-    check_autodeferring('ON');
-    check_contents("##r0$:##r1$:fish$:r3$:r4$:");
-  }
-  $it++;
-}
-
-# (48-56) Autodeferring should not become active during explicit defer mode
-$o->defer();  # This should flush the pending autodeferred records
-              # and deactivate autodeferring
-check_autodeferring('OFF');
-check_contents("##r0$:##r1$:##fish$:##r3$:##r4$:");
-@a = ("s0" .. "s4");
-check_autodeferring('OFF');
-check_contents("");
-$o->flush;
-check_autodeferring('OFF');
-check_contents("s0$:s1$:s2$:s3$:s4$:");
-
-undef $o; untie @a;
-
-# Limit cache+buffer size to 47 bytes 
-my $MAX = 47;
-#  -- that's enough space for 5 records, but not 6, on both \n and \r\n systems
-my $BUF = 20;
-#  -- that's enough space for 2 records, but not 3, on both \n and \r\n systems
-# Re-tie the object for more tests
-$o = tie @a, 'Tie::File', $file, autodefer => 0;
-die $! unless $o;
-# I am an undocumented feature
-$o->{autodefer_filelen_threshhold} = 0;
-# Normally autodeferring only works on large files.  This disables that.
-
-# (57-59) Did the autodefer => 0 option work?
-# (If it doesn't, a whole bunch of the other test files will fail.)
-@a = (0..3);
-check_autodeferring('OFF');
-check_contents(join("$:", qw(0 1 2 3), ""));
-
-# (60-62) Does the ->autodefer method work?
-$o->autodefer(1);
-@a = (10..13);
-check_autodeferring('ON');
-check_contents("$:$:$:$:");  # This might be unfortunate.
-
-# (63-65) Does the ->autodefer method work?
-$o->autodefer(0);
-check_autodeferring('OFF');
-check_contents(join("$:", qw(10 11 12 13), ""));
-
-
-sub check_autodeferring {
-  my ($x) = shift;
-  my $a = $o->{autodeferring} ? 'ON' : 'OFF';
-  if ($x eq $a) {
-    print "ok $N\n";
-  } else {
-    print "not ok $N \# Autodeferring was $a, expected it to be $x\n";
-  }
-  $N++;
-}
-
-
-sub check_contents {
-  my $x = shift;
-#  for (values %{$o->{cache}}) {
-#    print "# cache=$_";    
-#  }
-  
-  my $integrity = $o->_check_integrity($file, $ENV{INTEGRITY});
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-  print $integrity ? "ok $N\n" : "not ok $N\n";
-  $N++;
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    ctrlfix(my $msg = "# expected <$x>, got <$a>");
-    print "not ok $N\n$msg\n";
-  }
-  $N++;
-}
-
-sub ctrlfix {
-  for (@_) {
-    s/\n/\\n/g;
-    s/\r/\\r/g;
-  }
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/32_defer_misc.t b/ext/Tie-File/t/32_defer_misc.t
deleted file mode 100644
index e0e3f15bb8..0000000000
--- a/ext/Tie-File/t/32_defer_misc.t
+++ /dev/null
@@ -1,232 +0,0 @@
-#!/usr/bin/perl
-#
-# Check interactions of deferred writing
-# with miscellaneous methods like DELETE, EXISTS,
-# FETCHSIZE, STORESIZE, CLEAR, EXTEND
-#
-
-use POSIX 'SEEK_SET';
-my $file = "tf$$.txt";
-$: = Tie::File::_default_recsep();
-my $data = "rec0$:rec1$:rec2$:";
-my ($o, $n);
-
-print "1..53\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-open F, "> $file" or die $!;
-binmode F;
-print F $data;
-close F;
-$o = tie @a, 'Tie::File', $file;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# (3-6) EXISTS
-if ($] >= 5.006) {
-  eval << 'TESTS';
-$o->defer;
-expect(not exists $a[4]);
-$a[4] = "rec4";
-expect(exists $a[4]);
-check_contents($data);          # nothing written yet
-$o->discard;
-TESTS
-} else {
-    for (3..6) {
-      print "ok $_ \# skipped (no exists for arrays)\n";
-          $N++;
-    }
-}
-
-# (7-10) FETCHSIZE
-$o->defer;
-expect($#a, 2);
-$a[4] = "rec4";
-expect($#a, 4);
-check_contents($data);          # nothing written yet
-$o->discard;
-
-# (11-21) STORESIZE
-$o->defer;
-$#a = 4;
-check_contents($data);          # nothing written yet
-expect($#a, 4);
-$o->flush;
-expect($#a, 4);
-check_contents("$data$:$:");    # two extra empty records
-
-$o->defer;
-$a[4] = "rec4";
-$#a = 2;
-expect($a[4], undef);
-check_contents($data);          # written data was unwritten
-$o->flush;
-check_contents($data);          # nothing left to write
-
-# (22-28) CLEAR
-$o->defer;
-$a[9] = "rec9";
-check_contents($data);          # nothing written yet
-@a = ();
-check_contents("");             # this happens right away
-expect($a[9], undef);
-$o->flush;
-check_contents("");             # nothing left to write
-
-# (29-34) EXTEND
-# Actually it's not real clear what these tests are for
-# since EXTEND has no defined semantics
-$o->defer;
-@a = (0..3);
-check_contents("");             # nothing happened yet
-expect($a[3], "3");
-expect($a[4], undef);
-$o->flush;
-check_contents("0$:1$:2$:3$:"); # file now 4 records long
-
-# (35-53) DELETE
-if ($] >= 5.006) {
-  eval << 'TESTS';
-my $del;
-$o->defer;
-$del = delete $a[2];
-check_contents("0$:1$:2$:3$:"); # nothing happened yet
-expect($a[2], "");
-expect($del, "2");
-$del = delete $a[3];            # shortens file!
-check_contents("0$:1$:2$:");    # deferred writes NOT flushed
-expect($a[3], undef);
-expect($a[2], "");
-expect($del, "3");
-$a[2] = "cookies";
-$del = delete $a[2];            # shortens file!
-expect($a[2], undef);
-expect($del, 'cookies');
-check_contents("0$:1$:");
-$a[0] = "crackers";
-$del = delete $a[0];            # file unchanged
-expect($a[0], "");
-expect($del, 'crackers');
-check_contents("0$:1$:");       # no change yet
-$o->flush;
-check_contents("$:1$:");        # record 0 is NOT 'cookies';
-TESTS
-} else {
-    for (35..53) {
-      print "ok $_ \# skipped (no delete for arrays)\n";
-          $N++;
-    }
-}
-
-################################################################
-
-
-sub check_caches {
-  my ($xcache, $xdefer) = @_;
-
-#  my $integrity = $o->_check_integrity($file, $ENV{INTEGRITY});
-#  print $integrity ? "ok $N\n" : "not ok $N\n";
-#  $N++;
-
-  my $good = 1;
-  $good &&= hash_equal($o->{cache}, $xcache, "true cache", "expected cache");
-  $good &&= hash_equal($o->{deferred}, $xdefer, "true defer", "expected defer");
-  print $good ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-sub hash_equal {
-  my ($a, $b, $ha, $hb) = @_;
-  $ha = 'first hash'  unless defined $ha;
-  $hb = 'second hash' unless defined $hb;
-
-  my $good = 1;
-  my %b_seen;
-
-  for my $k (keys %$a) {
-    if (! exists $b->{$k}) {
-      print ctrlfix("# Key $k is in $ha but not $hb"), "\n";
-      $good = 0;
-    } elsif ($b->{$k} ne $a->{$k}) {
-      print ctrlfix("# Key $k is <$a->{$k}> in $ha but <$b->{$k}> in $hb"), "\n";
-      $b_seen{$k} = 1;
-      $good = 0;
-    } else {
-      $b_seen{$k} = 1;
-    }
-  }
-
-  for my $k (keys %$b) {
-    unless ($b_seen{$k}) {
-      print ctrlfix("# Key $k is in $hb but not $ha"), "\n";
-      $good = 0;
-    }
-  }
-
-  $good;
-}
-
-
-sub check_contents {
-  my $x = shift;
-
-  my $integrity = $o->_check_integrity($file, $ENV{INTEGRITY});
-  print $integrity ? "ok $N\n" : "not ok $N\n";
-  $N++;
-
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    my $msg = ctrlfix("# expected <$x>, got <$a>");
-    print "not ok $N\n$msg\n";
-  }
-  $N++;
-}
-
-sub expect {
-  if (@_ == 1) {
-    print $_[0] ? "ok $N\n" : "not ok $N\n";
-  } elsif (@_ == 2) {
-    my ($a, $x) = @_;
-    if    (! defined($a) && ! defined($x)) { print "ok $N\n" }
-    elsif (  defined($a) && ! defined($x)) { 
-      ctrlfix(my $msg = "expected UNDEF, got <$a>");
-      print "not ok $N \# $msg\n";
-    }
-    elsif (! defined($a) &&   defined($x)) { 
-      ctrlfix(my $msg = "expected <$x>, got UNDEF");
-      print "not ok $N \# $msg\n";
-    } elsif ($a eq $x) { print "ok $N\n" }
-    else {
-      ctrlfix(my $msg = "expected <$x>, got <$a>");
-      print "not ok $N \# $msg\n";
-    }
-  } else {
-    die "expect() got ", scalar(@_), " args, should have been 1 or 2";
-  }
-  $N++;
-}
-
-sub ctrlfix {
-  local $_ = shift;
-  s/\n/\\n/g;
-  s/\r/\\r/g;
-  $_;
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/33_defer_vs.t b/ext/Tie-File/t/33_defer_vs.t
deleted file mode 100644
index 071af77a68..0000000000
--- a/ext/Tie-File/t/33_defer_vs.t
+++ /dev/null
@@ -1,125 +0,0 @@
-#!/usr/bin/perl
-#
-# Deferred caching of varying size records
-#
-# 30_defer.t always uses records that are 8 bytes long
-# (9 on \r\n machines.)  We might miss some sort of
-# length-calculation bug as a result.  This file will run some of the same
-# tests, but with with varying-length records.
-#
-
-use POSIX 'SEEK_SET';
-my $file = "tf$$.txt";
-# print "1..0\n"; exit;
-$: = Tie::File::_default_recsep();
-my $data = "$:1$:22$:";
-my ($o, $n);
-
-print "1..30\n";
-
-my $N = 1;
-use Tie::File;
-print "ok $N\n"; $N++;
-
-open F, "> $file" or die $!;
-binmode F;
-print F $data;
-close F;
-$o = tie @a, 'Tie::File', $file;
-print $o ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# (3-6) Deferred storage
-$o->defer;
-$a[3] = "333";
-check_contents($data);          # nothing written yet
-$a[4] = "4444";
-check_contents($data);          # nothing written yet
-
-# (7-8) Flush
-$o->flush;
-check_contents($data . "333$:4444$:");          # now it's written
-
-# (9-12) Deferred writing disabled?
-$a[3] = "999999999";
-check_contents("${data}999999999$:4444$:");
-$a[4] = "88888888";
-check_contents("${data}999999999$:88888888$:");
-
-# (13-18) Now let's try two batches of records
-$#a = 2;
-$o->defer;
-$a[0] = "55555";
-check_contents($data);          # nothing written yet
-$a[2] = "aaaaaaaaaa";
-check_contents($data);          # nothing written yet
-$o->flush;
-check_contents("55555$:1$:aaaaaaaaaa$:");
-
-# (19-22) Deferred writing past the end of the file
-$o->defer;
-$a[4] = "7777777";
-check_contents("55555$:1$:aaaaaaaaaa$:");
-$o->flush;
-check_contents("55555$:1$:aaaaaaaaaa$:$:7777777$:");
-
-
-# (23-26) Now two long batches
-$o->defer;
-%l = qw(0 2  1 3  2 4  4 5  5 4  6 3);
-for (0..2, 4..6) {
-  $a[$_] = $_ x $l{$_};
-}
-check_contents("55555$:1$:aaaaaaaaaa$:$:7777777$:");
-$o->flush;
-check_contents(join $:, "00", "111", "2222", "", "44444", "5555", "666", "");
-
-# (27-30) Now let's make sure that discarded writes are really discarded
-# We have a 2Mib buffer here, so we can be sure that we aren't accidentally
-# filling it up
-$o->defer;
-for (0, 3, 7) {
-  $a[$_] = "discarded" . $_ x $_;
-}
-check_contents(join $:, "00", "111", "2222", "", "44444", "5555", "666", "");
-$o->discard;
-check_contents(join $:, "00", "111", "2222", "", "44444", "5555", "666", "");
-
-################################################################
-
-
-sub check_contents {
-  my $x = shift;
-
-  my $integrity = $o->_check_integrity($file, $ENV{INTEGRITY});
-  print $integrity ? "ok $N\n" : "not ok $N\n";
-  $N++;
-
-  local *FH = $o->{fh};
-  seek FH, 0, SEEK_SET;
-
-  my $a;
-  { local $/; $a = <FH> }
-  $a = "" unless defined $a;
-  if ($a eq $x) {
-    print "ok $N\n";
-  } else {
-    my $msg = ctrlfix("# expected <$x>, got <$a>");
-    print "not ok $N\n$msg\n";
-  }
-  $N++;
-}
-
-sub ctrlfix {
-  local $_ = shift;
-  s/\n/\\n/g;
-  s/\r/\\r/g;
-  $_;
-}
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}
-
diff --git a/ext/Tie-File/t/40_abs_cache.t b/ext/Tie-File/t/40_abs_cache.t
deleted file mode 100644
index 137c9bb78d..0000000000
--- a/ext/Tie-File/t/40_abs_cache.t
+++ /dev/null
@@ -1,281 +0,0 @@
-#!/usr/bin/perl
-#
-# Unit tests for abstract cache implementation
-#
-# Test the following methods:
-# * new()
-# * is_empty()
-# * empty()
-# * lookup(key)
-# * remove(key)
-# * insert(key,val)
-# * update(key,val)
-# * rekey(okeys,nkeys)
-# * expire()
-# * keys()
-# * bytes()
-# DESTROY()
-#
-# 20020327 You somehow managed to miss:
-# * reduce_size_to(bytes)
-#
-
-# print "1..0\n"; exit;
-print "1..42\n";
-
-my ($N, @R, $Q, $ar) = (1);
-
-use Tie::File;
-print "ok $N\n";
-$N++;
-
-my $h = Tie::File::Cache->new(10000) or die;
-print "ok $N\n";
-$N++;
-
-# (3) Are all the methods there?
-{
-  my $good = 1;
-  for my $meth (qw(new is_empty empty lookup remove
-                 insert update rekey expire ckeys bytes
-                   set_limit adj_limit flush  reduce_size_to
-                   _produce _produce_lru )) {
-    unless ($h->can($meth)) {
-      print STDERR "# Method '$meth' is missing.\n";
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-# (4-5) Straight insert and removal FIFO test
-$ar = 'a0';
-for (1..10) {
-  $h->insert($_, $ar++);
-}
-1;
-for (1..10) {
-  push @R, $h->expire;
-}
-$iota = iota('a',9);
-print "@R" eq $iota
-  ? "ok $N\n" : "not ok $N \# expected ($iota), got (@R)\n";
-$N++;
-check($h);
-
-# (6-7) Remove from empty heap
-$n = $h->expire;
-print ! defined $n ? "ok $N\n" : "not ok $N \# expected UNDEF, got $n";
-$N++;
-check($h);
-
-# (8-9) Interleaved insert and removal
-$Q = 0;
-@R = ();
-for my $i (1..4) {
-  for my $j (1..$i) {
-    $h->insert($Q, "b$Q");
-    $Q++;
-  }
-  for my $j (1..$i) {
-    push @R, $h->expire;
-  }
-}
-$iota = iota('b', 9);
-print "@R" eq $iota ? "ok $N\n" : "not ok $N \# expected ($iota), got (@R)\n";
-$N++;
-check($h);
-
-# (10) It should be empty now
-print $h->is_empty ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# (11-12) Insert and delete
-$Q = 1;
-for (1..10) {
-  $h->insert($_, "c$Q");
-  $Q++;
-}
-for (2, 4, 6, 8, 10) {
-  $h->remove($_);
-}
-@R = ();
-push @R, $n while defined ($n = $h->expire);
-print "@R" eq "c1 c3 c5 c7 c9" ? 
-  "ok $N\n" : "not ok $N \# expected (c1 c3 c5 c7 c9), got (@R)\n";
-$N++;
-check($h);
-
-# (13-14) Interleaved insert and delete
-$Q = 1; my $QQ = 1;
-@R = ();
-for my $i (1..4) {
-  for my $j (1..$i) {
-    $h->insert($Q, "d$Q");
-    $Q++;
-  }
-  for my $j (1..$i) {
-    $h->remove($QQ) if $QQ % 2 == 0;
-    $QQ++;
-  }
-}
-push @R, $n while defined ($n = $h->expire);
-print "@R" eq "d1 d3 d5 d7 d9" ? 
-  "ok $N\n" : "not ok $N \# expected (d1 d3 d5 d7 d9), got (@R)\n";
-$N++;
-check($h);
-
-# (15-16) Promote
-$h->empty;
-$Q = 1;
-for (1..10) {
-  $h->insert($_, "e$Q");
-  unless ($h->_check_integrity) {
-    die "Integrity failed after inserting ($_, e$Q)\n";
-  }
-  $Q++;
-}
-1;
-for (2, 4, 6, 8, 10) {
-  $h->_promote($_);
-}
-@R = ();
-push @R, $n while defined ($n = $h->expire);
-print "@R" eq "e1 e3 e5 e7 e9 e2 e4 e6 e8 e10" ? 
-    "ok $N\n" : 
-    "not ok $N \# expected (e1 e3 e5 e7 e9 e2 e4 e6 e8 e10), got (@R)\n";
-$N++;
-check($h);
-
-# (17-22) Lookup
-$Q = 1;
-for (1..10) {
-  $h->insert($_, "f$Q");
-  $Q++;
-}
-1;
-for (2, 4, 6, 4, 8) {
-  my $r = $h->lookup($_);
-  print $r eq "f$_" ? "ok $N\n" : "not ok $N \# expected f$_, got $r\n";
-  $N++;
-}
-check($h);
-
-# (23) It shouldn't be empty
-print ! $h->is_empty ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# (24-25) Lookup should have promoted the looked-up records
-@R = ();
-push @R, $n while defined ($n = $h->expire);
-print "@R" eq "f1 f3 f5 f7 f9 f10 f2 f6 f4 f8" ?
-  "ok $N\n" : 
-  "not ok $N \# expected (f1 f3 f5 f7 f9 f10 f2 f6 f4 f8), got (@R)\n";
-$N++;
-check($h);
-
-# (26-29) Typical 'rekey' operation
-$Q = 1;
-for (1..10) {
-  $h->insert($_, "g$Q");
-  $Q++;
-}
-$h->rekey([6,7,8,9,10], [8,9,10,11,12]);
-my %x = qw(1 g1 2 g2  3 g3  4 g4  5 g5
-           8 g6 9 g7 10 g8 11 g9 12 g10);
-{
-  my $good = 1;
-  for my $k (keys %x) {
-    my $v = $h->lookup($k);
-    $v = "UNDEF" unless defined $v;
-    unless ($v eq $x{$k}) {
-      print "# looked up $k, got $v, expected $x{$k}\n";
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-check($h);
-{
-  my $good = 1;
-  for my $k (6, 7) {
-    my $v = $h->lookup($k);
-    if (defined $v) {
-      print "# looked up $k, got $v, should have been undef\n";
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-check($h);
-
-# (30-31) ckeys
-@R = sort { $a <=> $b } $h->ckeys;
-print "@R" eq "1 2 3 4 5 8 9 10 11 12" ?
-  "ok $N\n" : 
-  "not ok $N \# expected (1 2 3 4 5 8 9 10 11 12) got (@R)\n";
-$N++;
-check($h);
-1;
-# (32-33) update
-for (1..5, 8..12) {
-  $h->update($_, "h$_");
-}
-@R = ();
-for (sort { $a <=> $b } $h->ckeys) {
-  push @R, $h->lookup($_);
-}
-print "@R" eq "h1 h2 h3 h4 h5 h8 h9 h10 h11 h12" ?
-  "ok $N\n" : 
-  "not ok $N \# expected (h1 h2 h3 h4 h5 h8 h9 h10 h11 h12) got (@R)\n";
-$N++;
-check($h);
-
-# (34-37) bytes
-my $B;
-$B = $h->bytes;
-print $B == 23 ? "ok $N\n" : "not ok $N \# expected 23, got $B\n";
-$N++;
-check($h);
-$h->update('12', "yobgorgle");
-$B = $h->bytes;
-print $B == 29 ? "ok $N\n" : "not ok $N \# expected 29, got $B\n";
-$N++;
-check($h);
-
-# (38-41) empty
-$h->empty;
-print $h->is_empty ? "ok $N\n" : "not ok $N\n";
-$N++;
-check($h);
-$n = $h->expire;
-print ! defined $n ? "ok $N\n" : "not ok $N \# expected UNDEF, got $n";
-$N++;
-check($h);
-
-# (42) very weak testing of DESTROY
-undef $h;
-# are we still alive?
-print "ok $N\n";
-$N++;
-
-sub check {
-  my $h = shift;
-  print $h->_check_integrity ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-sub iota {
-  my ($p, $n) = @_;
-  my $r;
-  my $i = 0;
-  while ($i <= $n) {
-    $r .= "$p$i ";
-    $i++;
-  }
-  chop $r;
-  $r;
-}
diff --git a/ext/Tie-File/t/41_heap.t b/ext/Tie-File/t/41_heap.t
deleted file mode 100644
index 9e7ad2516c..0000000000
--- a/ext/Tie-File/t/41_heap.t
+++ /dev/null
@@ -1,259 +0,0 @@
-#!/usr/bin/perl
-#
-# Unit tests for heap implementation
-#
-# Test the following methods:
-# new
-# is_empty
-# empty
-# insert
-# remove
-# popheap
-# promote
-# lookup
-# set_val
-# rekey
-# expire_order
-
-
-# Finish these later.
-
-# They're nonurgent because the important heap stuff is extensively
-# tested by tests 19, 20, 24, 30, 32, 33, and 40, as well as by pretty
-# much everything else.
-print "1..1\n";
-
-
-my ($N, @R, $Q, $ar) = (1);
-
-use Tie::File;
-print "ok $N\n";
-$N++;
-exit;
-
-__END__
-
-my @HEAP_MOVE;
-sub Fake::Cache::_heap_move { push @HEAP_MOVE, @_ }
-
-my $h = Tie::File::Heap->new(bless [] => 'Fake::Cache');
-print "ok $N\n";
-$N++;
-
-# (3) Are all the methods there?
-{
-  my $good = 1;
-  for my $meth (qw(new is_empty empty lookup insert remove popheap
-                   promote set_val rekey expire_order)) {
-    unless ($h->can($meth)) {
-      print STDERR "# Method '$meth' is missing.\n";
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-# (4) Straight insert and removal FIFO test
-$ar = 'a0';
-for (1..10) {
-  $h->insert($_, $ar++);
-}
-for (1..10) {
-  push @R, $h->popheap;
-}
-$iota = iota('a',9);
-print "@R" eq $iota
-  ? "ok $N\n" : "not ok $N \# expected ($iota), got (@R)\n";
-$N++;
-
-# (5) Remove from empty heap
-$n = $h->popheap;
-print ! defined $n ? "ok $N\n" : "not ok $N \# expected UNDEF, got $n";
-$N++;
-
-# (6) Interleaved insert and removal
-$Q = 0;
-@R = ();
-for my $i (1..4) {
-  for my $j (1..$i) {
-    $h->insert($Q, "b$Q");
-    $Q++;
-  }
-  for my $j (1..$i) {
-    push @R, $h->popheap;
-  }
-}
-$iota = iota('b', 9);
-print "@R" eq $iota ? "ok $N\n" : "not ok $N \# expected ($iota), got (@R)\n";
-$N++;
-
-# (7) It should be empty now
-print $h->is_empty ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# (8) Insert and delete
-$Q = 1;
-for (1..10) {
-  $h->insert($_, "c$Q");
-  $Q++;
-}
-for (2, 4, 6, 8, 10) {
-  $h->remove($_);
-}
-@R = ();
-push @R, $n while defined ($n = $h->popheap);
-print "@R" eq "c1 c3 c5 c7 c9" ? 
-  "ok $N\n" : "not ok $N \# expected (c1 c3 c5 c7 c9), got (@R)\n";
-$N++;
-
-# (9) Interleaved insert and delete
-$Q = 1; my $QQ = 1;
-@R = ();
-for my $i (1..4) {
-  for my $j (1..$i) {
-    $h->insert($Q, "d$Q");
-    $Q++;
-  }
-  for my $j (1..$i) {
-    $h->remove($QQ) if $QQ % 2 == 0;
-    $QQ++;
-  }
-}
-push @R, $n while defined ($n = $h->popheap);
-print "@R" eq "d1 d3 d5 d7 d9" ? 
-  "ok $N\n" : "not ok $N \# expected (d1 d3 d5 d7 d9), got (@R)\n";
-$N++;
-
-# (10) Promote
-$Q = 1;
-for (1..10) {
-  $h->insert($_, "e$Q");
-  $Q++;
-}
-for (2, 4, 6, 8, 10) {
-  $h->promote($_);
-}
-@R = ();
-push @R, $n while defined ($n = $h->popheap);
-print "@R" eq "e1 e3 e5 e7 e9 e2 e4 e6 e8 e10" ? 
-  "ok $N\n" : 
-  "not ok $N \# expected (e1 e3 e5 e7 e9 e2 e4 e6 e8 e10), got (@R)\n";
-$N++;
-
-# (11-15) Lookup
-$Q = 1;
-for (1..10) {
-  $h->insert($_, "f$Q");
-  $Q++;
-}
-for (2, 4, 6, 4, 8) {
-  my $r = $h->lookup($_);
-  print $r eq "f$_" ? "ok $N\n" : "not ok $N \# expected f$_, got $r\n";
-  $N++;
-}
-
-# (16) It shouldn't be empty
-print ! $h->is_empty ? "ok $N\n" : "not ok $N\n";
-$N++;
-
-# (17) Lookup should have promoted the looked-up records
-@R = ();
-push @R, $n while defined ($n = $h->popheap);
-print "@R" eq "f1 f3 f5 f7 f9 f10 f2 f6 f4 f8" ?
-  "ok $N\n" : 
-  "not ok $N \# expected (f1 f3 f5 f7 f9 f10 f2 f6 f4 f8), got (@R)\n";
-$N++;
-
-# (18-19) Typical 'rekey' operation
-$Q = 1;
-for (1..10) {
-  $h->insert($_, "g$Q");
-  $Q++;
-}
-
-$h->rekey([6,7,8,9,10], [8,9,10,11,12]);
-my %x = qw(1 g1 2 g2  3 g3  4 g4  5 g5
-           8 g6 9 g7 10 g8 11 g9 12 g10);
-{
-  my $good = 1;
-  for my $k (keys %x) {
-    my $v = $h->lookup($k);
-    $v = "UNDEF" unless defined $v;
-    unless ($v eq $x{$k}) {
-      print "# looked up $k, got $v, expected $x{$k}\n";
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-{
-  my $good = 1;
-  for my $k (6, 7) {
-    my $v = $h->lookup($k);
-    if (defined $v) {
-      print "# looked up $k, got $v, should have been undef\n";
-      $good = 0;
-    }
-  }
-  print $good ? "ok $N\n" : "not ok $N\n";
-  $N++;
-}
-
-# (20) keys
-@R = sort { $a <=> $b } $h->keys;
-print "@R" eq "1 2 3 4 5 8 9 10 11 12" ?
-  "ok $N\n" : 
-  "not ok $N \# expected (1 2 3 4 5 8 9 10 11 12) got (@R)\n";
-$N++;
-
-# (21) update
-for (1..5, 8..12) {
-  $h->update($_, "h$_");
-}
-@R = ();
-for (sort { $a <=> $b } $h->keys) {
-  push @R, $h->lookup($_);
-}
-print "@R" eq "h1 h2 h3 h4 h5 h8 h9 h10 h11 h12" ?
-  "ok $N\n" : 
-  "not ok $N \# expected (h1 h2 h3 h4 h5 h8 h9 h10 h11 h12) got (@R)\n";
-$N++;
-
-# (22-23) bytes
-my $B;
-$B = $h->bytes;
-print $B == 23 ? "ok $N\n" : "not ok $N \# expected 23, got $B\n";
-$N++;
-$h->update('12', "yobgorgle");
-$B = $h->bytes;
-print $B == 29 ? "ok $N\n" : "not ok $N \# expected 29, got $B\n";
-$N++;
-
-# (24-25) empty
-$h->empty;
-print $h->is_empty ? "ok $N\n" : "not ok $N\n";
-$N++;
-$n = $h->popheap;
-print ! defined $n ? "ok $N\n" : "not ok $N \# expected UNDEF, got $n";
-$N++;
-
-# (26) very weak testing of DESTROY
-undef $h;
-# are we still alive?
-print "ok $N\n";
-$N++;
-
-
-sub iota {
-  my ($p, $n) = @_;
-  my $r;
-  my $i = 0;
-  while ($i <= $n) {
-    $r .= "$p$i ";
-    $i++;
-  }
-  chop $r;
-  $r;
-}
diff --git a/ext/Tie-File/t/42_offset.t b/ext/Tie-File/t/42_offset.t
deleted file mode 100644
index 8c628325d9..0000000000
--- a/ext/Tie-File/t/42_offset.t
+++ /dev/null
@@ -1,69 +0,0 @@
-#!/usr/bin/perl
-
-# 2003-04-09 Tels: test the offset method from 0.94
-
-use Test::More;
-use strict;
-use File::Spec;
-
-use POSIX 'SEEK_SET';
-my $file = "tf$$.txt";
-
-BEGIN
-  {
-  $| = 1;
-  unshift @INC, File::Spec->catdir(File::Spec->updir, 'lib');
-  chdir 't' if -d 't';
-  print "# INC = @INC\n";
-
-  plan tests => 24;
-
-  use_ok ('Tie::File');
-  }
-
-$/ = "#";	# avoid problems with \n\r vs. \n
-
-my @a;
-my $o = tie @a, 'Tie::File', $file, autodefer => 0;
-
-is (ref($o), 'Tie::File');
-
-is ($o->offset(0), 0, 'first one always there');
-is ($o->offset(1), undef, 'no offsets yet');
-
-$a[0] = 'Bourbon';
-is ($o->offset(0), 0, 'first is ok');
-is ($o->offset(1), 8, 'and second ok');
-is ($o->offset(2), undef, 'third undef');
-
-$a[1] = 'makes';
-is ($o->offset(0), 0, 'first is ok');
-is ($o->offset(1), 8, 'and second ok');
-is ($o->offset(2), 14, 'and third ok');
-is ($o->offset(3), undef, 'fourth undef');
-
-$a[2] = 'the baby';
-is ($o->offset(0), 0, 'first is ok');
-is ($o->offset(1), 8, 'and second ok');
-is ($o->offset(2), 14, 'and third ok');
-is ($o->offset(3), 23, 'and fourth ok');
-is ($o->offset(4), undef, 'fourth undef');
-
-$a[3] = 'grin';
-is ($o->offset(0), 0, 'first is ok');
-is ($o->offset(1), 8, 'and second ok');
-is ($o->offset(2), 14, 'and third ok');
-is ($o->offset(3), 23, 'and fourth ok');
-is ($o->offset(4), 28, 'and fifth ok');
-
-$a[4] = '!';
-is ($o->offset(5), 30, 'and fifth ok');
-$a[3] = 'water';
-is ($o->offset(4), 29, 'and fourth changed ok');
-is ($o->offset(5), 31, 'and fifth ok');
-
-END {
-  undef $o;
-  untie @a;
-  1 while unlink $file;
-}