view release on metacpan or  search on metacpan

t/pdf.t  view on Meta::CPAN

      ok($tree->computeGS(), "page $page, computeGS");

      ## Too slow
    #SKIP:
    #  {
    #     skip 'optional memory leak test skipped', 1 if (!$can_test_leaks);
    #     Test::Memory::Cycle::memory_cycle_ok($tree, 'memory leak test');
    #  }
   }

   # Maybe trim some pages to speed up the tests
   my @delete_pagenums = grep {$testdoc->{pages}->[$_-1] && $testdoc->{pages}->[$_-1]->{skip}} 1 .. $pages;
   $doc->deletePages(@delete_pagenums);
   $pages = $doc->numPages();

   # Add some pages
   {
      my $dupe = CAM::PDF->new($file);
      $dupe->deletePages(@delete_pagenums);
      checkerr();
      $doc->appendPDF($dupe);
      $doc->appendPDF($dupe);
      $doc->appendPDF($dupe);
   }

 SKIP:
   {
      skip 'optional memory leak test skipped', 1 if (!$can_test_leaks);
      Test::Memory::Cycle::memory_cycle_ok($doc, 'memory leak test');
   }

   $doc->cleansave();
   is($doc->numPages(), $pages * 4, 'append pages');
   is($doc->isLinearized(), undef, 'isLinearized');
   ok($doc->extractPages($pages + 1, $pages * 3 + 1), 'extract pages');
   $doc->cleansave();
   is($doc->numPages(), 2, 'extract page check');

   ok($doc->deletePages($doc->numPages()), 'delete pages');
   $doc->cleansave();
   is($doc->numPages(), 1, 'delete page check');

   ok($doc->duplicatePage(1), 'duplicatePage'); 
   is($doc->numPages(), 2, 'duplicate page check');
   is($doc->getPageContent(1), $doc->getPageContent($doc->numPages()), 'duplicate page check');

   my @passwords = ('foo', 'bar');
   my @initial_permissions = @{ $testdoc->{permissions} || [1,1,1,1] };
   is_deeply([$doc->getPrefs()], [undef, undef, @initial_permissions], 'getPrefs');
   is($doc->canPrint(),  $initial_permissions[0], 'canPrint');
   is($doc->canModify(), $initial_permissions[1], 'canModify');
   is($doc->canCopy(),   $initial_permissions[2], 'canCopy');
   is($doc->canAdd(),    $initial_permissions[3], 'canAdd');
   $doc->setPrefs(@passwords);
   is_deeply([$doc->getPrefs()], [@passwords, 0,0,0,0], 'getPrefs');
   ok(!$doc->canPrint(),  'canPrint');
   ok(!$doc->canModify(), 'canModify');
   ok(!$doc->canCopy(),   'canCopy');
   ok(!$doc->canAdd(),    'canAdd');

   my @prefs = (1,0,1,0);
   $doc->setPrefs(@passwords, @prefs);
   $doc->setPrefs(@passwords, @prefs);
   is_deeply([$doc->getPrefs()], [@passwords, @prefs], 'getPrefs');

 SKIP:
   {
      skip 'optional memory leak test skipped', 1 if (!$can_test_leaks);
      Test::Memory::Cycle::memory_cycle_ok($doc, 'memory leak test');
   }

   {
      my $doc2;
      my $serialized = $doc->toPDF();
      ok($serialized, 'serialized encrypted PDF');
      
      $doc2 = CAM::PDF->new($serialized);
      is($doc2, undef, 'open encrypted PDF, no password');
      
      $doc2 = CAM::PDF->new($serialized, 'wrong', 'password');
      is($doc2, undef, 'open encrypted PDF, wrong password');
      
      $doc2 = CAM::PDF->new($serialized, '', '', {fault_tolerant => 1});
      isnt($doc2, undef, 'open encrypted PDF, fail gently');
      
      clearerr();
      $doc2 = CAM::PDF->new($serialized, @passwords);
      isnt($doc2, undef, 'open encrypted PDF, right password');
      checkerr();
      is_deeply([$doc2 ? $doc2->getPrefs() : ()], [@passwords, @prefs], 'getPrefs');

    SKIP:
      {
         skip 'optional memory leak test skipped', 1 if (!$can_test_leaks);
         Test::Memory::Cycle::memory_cycle_ok($doc2, 'memory leak test');
      }
   }
}


sub filter_testdocs
{
   my @testdocs = grep {$_->{filename} && -f $_->{filename}} @_;

   # Choose one or neither of these.  The first is for production, the second is for debugging
   if ($ENV{SKIP_BIG_PDF})
   {
      @testdocs = grep {$_->{filename} !~ /PDFReference/} @testdocs;
   }

   {
      # Disable some PDFReference pages we know we can't handle
      # ALL of these are due to q..Q and BDC..EMC blocks not nesting
      
      my ($testdoc) = grep {$_->{filename} =~ /PDFReference/} @testdocs;
      if ($testdoc)
      {
         for my $page (89, 97, 167, 194, 208..210, 225, 226, 230,
                       302, 304, 307, 308, 313, 323, 324, 375, 376,
                       377, 380, 384, 386, 387, 392, 408, 443, 471..475,
                       482, 491, 494, 580, 601, 670, 842, 947, 949,
                       954, 1009..1020)
         {
            next if (!$testdoc->{pages}->[$page-1]);
            $testdoc->{pages}->[$page-1]->{skip} = 1;
         }
      }
   }
   
   for my $testdoc (@testdocs)
   {
      my @pages = grep {!$_->{skip}} @{$testdoc->{pages}};
      if (@pages > $max_pages)
      {
         my $head_end     = $begin_pages;
         my $middle_pages = $max_pages - $begin_pages - $end_pages;
         my $middle_start = $begin_pages + int((@pages - $max_pages)/2);
         my $middle_end   = $middle_start + $middle_pages;
         my $tail_start   = @pages - $end_pages;
         
         for my $p ($head_end+1 .. $middle_start, $middle_end+1 .. $tail_start)
         {
            $pages[$p-1]->{skip} = 1;
         }
      }
   }
   
   return @testdocs;
}