view release on metacpan or  search on metacpan

t/resolveit  view on Meta::CPAN

 $filtered
);
isa_ok( $resolve,'Thread::Pool::Resolve', 'check object type' );
ok( $resolve->read( $log ),		'read from opened IO::File' );
$resolve->shutdown;
ok( check( $resolved,$filtered ),	'check result of opened IO::File' );
ok( close( $log ),			'close IO::File log file' );

diag( "Test resolving from a SCALAR handle ($optimize)" );
ok( open( $log,'<',$unresolved ),	'check opening unresolved file' );
my $scalar;
{local $/; $scalar = <$log>}
ok( close( $log ),			'check closing unresolved file' );

ok( open( $log,'<',\$scalar ),		'check SCALAR handle' );
my $output;
$resolve = Thread::Pool::Resolve->new(
 {
  optimize => $optimize,
  pre => sub { open( $output,'>',$filtered ) or die "$filtered: $!" },
  monitor => sub { print $output $_[0] },
  post => sub { close( $output ) },
  resolver => 'gethostbyaddr',
 }
);
isa_ok( $resolve,'Thread::Pool::Resolve', 'check object type' );
ok( $resolve->read( $log ),		'read from opened SCALAR' );
$resolve->shutdown;
ok( check( $resolved,$filtered ),	'check result of opened SCALAR' );
ok( close( $log ),			'close IO::File log file' );

diag( "Test resolving from a list ($optimize)" );
ok( open( $log,'<',$unresolved ),	'check opening unresolved file' );
my @array = <$log>;
ok( close( $log ),			'check closing unresolved file' );
$resolve = Thread::Pool::Resolve->new(
 {
  optimize => $optimize,
  resolver => 'gethostbyaddr',
 },
 $filtered
);
isa_ok( $resolve,'Thread::Pool::Resolve', 'check object type' );
ok( $resolve->lines( @array ),		'check object returned from lines' );
$resolve->shutdown;
ok( check( $resolved,$filtered ),	'check result from lines' );

diag( "Test resolving from different threads ($optimize)" );
@shared = @array;
$resolve = Thread::Pool::Resolve->new(
 {
  optimize => $optimize,
  resolver => 'gethostbyaddr',
 },
 $filtered
);
isa_ok( $resolve,'Thread::Pool::Resolve', 'check object type' );
my @thread;
push( @thread,threads->new( \&bythread ) ) foreach 1..10;
$_->join foreach @thread;
$resolve = undef; # needed to finalize streaming in time
ok( check( $resolved,$filtered ),	'check result different threads' );

diag( "Test resolving from Thread::Queue ($optimize)" );
@shared = (@array,undef);
my $queue = bless \@shared,'Thread::Queue';
isa_ok( $queue,'Thread::Queue',		'check object type' );
$resolve = Thread::Pool::Resolve->new(
 {
  status => \%status,
  optimize => $optimize,
  resolver => 'gethostbyaddr',
 },
 $filtered
);
isa_ok( $resolve,'Thread::Pool::Resolve', 'check object type' );
ok( $resolve->read( $queue ),		'check result of reading with queue' );
$resolve = undef;
ok( check( $resolved,$filtered ),	'check result Thread::Queue' );

diag( "Test resolving using Thread::Conveyor ($optimize)" );
my $belt = Thread::Conveyor->new( {optimize => $optimize} );
isa_ok( $belt,'Thread::Conveyor',	'check object type' );
$belt->put( $_ ) foreach @array,undef;
$resolve = Thread::Pool::Resolve->new(
 {
  optimize => $optimize,
  resolved => retrieve( $ip2domain ),
  resolver => 'gethostbyaddr',
 },
 $filtered
);
isa_ok( $resolve,'Thread::Pool::Resolve', 'check object type' );
ok( $resolve->read( $belt ),		'check result of reading with belt' );
$resolve = undef;
ok( check( $resolved,$filtered ),	'check result Thread::Conveyor' );

ok( unlink( $unresolved,$resolved,$filter,$filtered ), 'remove created files' );

#=======================================================================

# necessary subroutines

# adding resolve lines by shared array per thread

sub bythread {
  local ($_);
  READ: while (1) {
    {lock( @shared );
     my $line = shift( @shared );
     last READ unless defined( $line );
     $resolve->line( $line );
    }
  }
}

# resolve from the dummy hash

sub gethostbyaddr { select( undef,undef,undef,rand() ); $ip2domain{$_[0]} }

# check two files and return true if they are the same