origami 1.0.2

data/tests/tc_pdfattach.rb

@@ -0,0 +1,24 @@
+require 'test/unit'
+require 'stringio'
+
+  class TC_PdfAttach < Test::Unit::TestCase
+    def setup
+      @target = PDF.new
+      @attachment = "tests/dataset/test.dummycrt"
+      @output = StringIO.new
+    end
+
+    # def teardown
+    # end
+
+    def test_attachfile
+      assert_nothing_raised do
+        fspec = @target.attach_file(@attachment, :EmbeddedName => "foo.bar")
+      end
+
+      assert_nothing_raised do
+        @target.save(@output)
+      end
+    end
+
+end

data/tests/tc_pdfencrypt.rb

@@ -0,0 +1,110 @@
+require 'test/unit'
+require 'stringio'
+
+  class TC_PdfEncrypt < Test::Unit::TestCase
+    def setup
+      @target = PDF.read("tests/dataset/calc.pdf", :ignore_errors => false, :verbosity => Parser::VERBOSE_QUIET)
+      @output = StringIO.new
+    end
+
+    # def teardown
+    # end
+
+    def test_encrypt_rc4_40b
+      @output.string = ""
+      assert_nothing_raised do
+        @target.encrypt(:cipher => 'rc4', :key_size => 40).save(@output);
+      end
+    end
+
+    def test_encrypt_rc4_128b
+      @output.string = ""
+      assert_nothing_raised do
+        @target.encrypt(:cipher => 'rc4').save(@output);
+      end
+    end
+
+    def test_encrypt_aes_128b
+      @output.string = ""
+      assert_nothing_raised do
+        @target.encrypt(:cipher => 'aes').save(@output);
+      end
+    end
+
+    def test_decrypt_rc4_40b
+      pdf = nil
+      @output.string = ""
+      assert_nothing_raised do
+        pdf = PDF.new.encrypt(:cipher => 'rc4', :key_size => 40)
+        pdf.Catalog[:Test] = "test"
+        pdf.save(@output)
+      end
+
+      assert_not_equal pdf.Catalog[:Test], "test"
+
+      assert_nothing_raised do
+        @output = @output.reopen(@output.string, "r")
+        pdf = PDF.read(@output, :ignore_errors => false, :verbosity => Parser::VERBOSE_QUIET)
+      end
+
+      assert_equal pdf.Catalog[:Test], "test"
+    end
+
+    def test_decrypt_rc4_128b
+      pdf = nil
+      @output.string = ""
+      assert_nothing_raised do
+        pdf = PDF.new.encrypt(:cipher => 'rc4')
+        pdf.Catalog[:Test] = "test"
+        pdf.save(@output)
+      end
+
+      assert_not_equal pdf.Catalog[:Test], "test"
+
+      assert_nothing_raised do
+        @output.reopen(@output.string, "r")
+        pdf = PDF.read(@output, :ignore_errors => false, :verbosity => Parser::VERBOSE_QUIET)
+      end
+
+      assert_equal pdf.Catalog[:Test], "test"
+    end
+
+    def test_decrypt_aes_128b
+      pdf = nil
+      @output.string = ""
+      assert_nothing_raised do
+        pdf = PDF.new.encrypt(:cipher => 'aes')
+        pdf.Catalog[:Test] = "test"
+        pdf.save(@output)
+      end
+
+      assert_not_equal pdf.Catalog[:Test], "test"
+
+      assert_nothing_raised do
+        @output = @output.reopen(@output.string, "r")
+        pdf = PDF.read(@output, :ignore_errors => false, :verbosity => Parser::VERBOSE_QUIET)
+      end
+
+      assert_equal pdf.Catalog[:Test], "test"
+    end
+
+    def test_decrypt_aes_256b
+      pdf = nil
+      @output.string = ""
+      assert_nothing_raised do
+        pdf = PDF.new.encrypt(:cipher => 'aes', :key_size => 256)
+        pdf.Catalog[:Test] = "test"
+        pdf.save(@output)
+      end
+
+      assert_not_equal pdf.Catalog[:Test], "test"
+
+      assert_nothing_raised do
+        @output = @output.reopen(@output.string, "r")
+        pdf = PDF.read(@output, :ignore_errors => false, :verbosity => Parser::VERBOSE_QUIET)
+      end
+
+      assert_equal pdf.Catalog[:Test], "test"
+    end
+
+end

data/tests/tc_pdfnew.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+require 'stringio'
+
+  class TC_PdfNew < Test::Unit::TestCase
+
+    def setup
+      @output = StringIO.new
+    end
+
+    # def teardown
+    # end
+
+    def test_pdf_struct
+
+      pdf = PDF.new
+
+      null = Null.new
+      assert_nothing_raised do
+        pdf << null
+      end
+
+      assert_nothing_raised do
+        pdf.save(@output)
+      end
+
+      assert null.is_indirect?
+      assert pdf.objects.include?(null)
+      assert_equal pdf.revisions.first.body[null.reference], null
+      assert_equal null.reference.solve, null
+    end
+
+end

data/tests/tc_pdfparse.rb

@@ -0,0 +1,98 @@
+require 'test/unit'
+
+  class TC_PdfParse < Test::Unit::TestCase
+    def setup
+      @data = 
+        %w{ 
+          tests/dataset/empty.pdf
+          tests/dataset/calc.pdf 
+          tests/dataset/crypto.pdf
+          }
+
+      @dict = StringScanner.new "<</N 2 0 R/x1 null/Pi 3.14 /a <<>>>>"
+
+      @bytestring = StringScanner.new "(\\122\\125by\\n)"
+      @hexastring = StringScanner.new "<52  55  62 79 0A>"
+      @true = StringScanner.new "true"
+      @false = StringScanner.new "false"
+      @real = StringScanner.new "-3.141592653"
+      @int = StringScanner.new "00000000002000000000000"
+      @name = StringScanner.new "/#52#55#62#79#0A"
+    end
+
+    # def teardown
+    # end
+
+    def test_parsepdf
+      @data.each { |file|
+        assert_nothing_raised do
+          PDF.read(file, :ignore_errors => false, :verbosity => Parser::VERBOSE_QUIET)
+        end
+      }
+    end
+
+    def test_parsedictionary
+
+      dict = nil
+      assert_nothing_raised do
+        dict = Dictionary.parse(@dict)
+      end
+
+      assert dict[:Pi] == 3.14
+      assert dict[:a].is_a?(Dictionary)
+
+    end
+
+    def test_parsestring
+      str = nil
+      assert_nothing_raised do
+        str = ByteString.parse(@bytestring)
+      end
+
+      assert str.value == "RUby\n"
+
+      assert_nothing_raised do
+        str = HexaString.parse(@hexastring)
+      end
+
+      assert str.value == "RUby\n"
+    end
+
+    def test_parsebool
+      _true, _false = nil
+      assert_nothing_raised do
+        _true = Boolean.parse(@true)
+        _false = Boolean.parse(@false)
+      end
+
+      assert _false.false?
+      assert (not _true.false?)
+    end
+
+    def test_parsereal
+      real = nil
+      assert_nothing_raised do
+        real = Real.parse(@real)
+      end
+
+      assert_equal real, -3.141592653
+    end
+
+    def test_parseint
+      int = nil
+      assert_nothing_raised do
+        int = Origami::Integer.parse(@int)
+      end
+
+      assert_equal int, 2000000000000
+    end
+
+    def test_parsename
+      name = nil
+      assert_nothing_raised do
+        name = Name.parse(@name)
+      end
+
+      assert_equal name.value, :"RUby\n"
+    end
+end

data/tests/tc_pdfsig.rb

@@ -0,0 +1,37 @@
+require 'test/unit'
+require 'stringio'
+
+  class TC_PdfSig < Test::Unit::TestCase
+
+    def setup
+      @target = PDF.read("tests/dataset/calc.pdf", :ignore_errors => false, :verbosity => Parser::VERBOSE_QUIET)
+      @output = StringIO.new
+ 
+      @cert = OpenSSL::X509::Certificate.new(File.open("tests/dataset/test.dummycrt").read)
+      @key = OpenSSL::PKey::RSA.new(File.open("tests/dataset/test.dummykey").read)
+    end
+
+    # def teardown
+    # end
+
+    def test_sig
+
+      sigannot = Annotation::Widget::Signature.new.set_indirect(true)
+      sigannot.Rect = Rectangle[:llx => 89.0, :lly => 386.0, :urx => 190.0, :ury => 353.0]
+
+      assert_nothing_raised do
+        @target.append_page(page = Page.new)
+        page.add_annot(sigannot)
+
+        @target.sign(@cert, @key, [], sigannot, "France", "fred@security-labs.org", "Proof of Concept (owned)")
+      end
+
+      assert @target.frozen?
+
+      assert_nothing_raised do
+        @target.save(@output)
+      end
+
+    end
+
+end

data/tests/tc_streams.rb

@@ -0,0 +1,129 @@
+require 'test/unit'
+require 'stringio'
+
+  class TC_Streams < Test::Unit::TestCase
+    def setup
+      @target = PDF.new
+      @output = StringIO.new
+      @data = "0123456789" * 1024
+    end
+
+    # def teardown
+    # end
+    
+    def test_predictors
+
+      stm = Stream.new(@data, :Filter => :FlateDecode)
+      stm.set_predictor(Filter::Predictor::TIFF)
+      raw = stm.rawdata
+      stm.data = nil
+      stm.rawdata = raw
+
+      assert_equal @data, stm.data
+
+      stm = Stream.new(@data, :Filter => :FlateDecode)
+      stm.set_predictor(Filter::Predictor::PNG_SUB)
+      raw = stm.rawdata
+      stm.data = nil
+      stm.rawdata = raw
+
+      assert_equal @data, stm.data
+
+      stm = Stream.new(@data, :Filter => :FlateDecode)
+      stm.set_predictor(Filter::Predictor::PNG_UP)
+      raw = stm.rawdata
+      stm.data = nil
+      stm.rawdata = raw
+
+      assert_equal stm.data, @data
+
+      stm = Stream.new(@data, :Filter => :FlateDecode)
+      stm.set_predictor(Filter::Predictor::PNG_AVERAGE)
+      raw = stm.rawdata
+      stm.data = nil
+      stm.rawdata = raw
+
+      assert_equal stm.data, @data
+
+      stm = Stream.new(@data, :Filter => :FlateDecode)
+      stm.set_predictor(Filter::Predictor::PNG_PAETH)
+      raw = stm.rawdata
+      stm.data = nil
+      stm.rawdata = raw
+
+      assert_equal stm.data, @data
+
+   end
+   
+    def test_filter_flate
+
+      stm = Stream.new(@data, :Filter => :FlateDecode)
+      raw = stm.rawdata
+      stm.data = nil
+      stm.rawdata = raw
+
+      assert_equal stm.data, @data
+    end
+
+    def test_filter_asciihex
+
+      stm = Stream.new(@data, :Filter => :ASCIIHexDecode)
+      raw = stm.rawdata
+      stm.data = nil
+      stm.rawdata = raw
+
+      assert_equal stm.data, @data
+    end
+
+    def test_filter_ascii85
+
+      stm = Stream.new(@data, :Filter => :ASCII85Decode)
+      raw = stm.rawdata
+      stm.data = nil
+      stm.rawdata = raw
+
+      assert_equal stm.data, @data
+    end
+
+    def test_filter_rle
+
+      stm = Stream.new(@data, :Filter => :RunLengthDecode)
+      raw = stm.rawdata
+      stm.data = nil
+      stm.rawdata = raw
+
+      assert_equal stm.data, @data
+    end
+
+    def test_filter_lzw
+
+      stm = Stream.new(@data, :Filter => :LZWDecode)
+      raw = stm.rawdata
+      stm.data = nil
+      stm.rawdata = raw
+
+      assert_equal stm.data, @data
+    end
+
+    def test_filter_ccittfax
+      
+      stm = Stream.new(@data[0, 216], :Filter => :CCITTFaxDecode)
+      
+      raw = stm.rawdata
+      stm.data = nil
+      stm.rawdata = raw
+
+      assert_equal stm.data, @data[0, 216]
+    end
+
+    def test_stream
+      stm = Stream.new(@data, :Filter => :ASCIIHexDecode )
+      @target << stm
+
+      stm.pre_build
+      assert stm.Length == stm.rawdata.length
+
+      @target.save(@output)
+    end
+
+end

data/tests/ts_pdf.rb

@@ -0,0 +1,45 @@
+require 'test/unit/testsuite'
+require 'tc_pdfparse.rb'
+require 'tc_streams.rb'
+require 'tc_pdfencrypt.rb'
+require 'tc_pdfsig.rb'
+require 'tc_pdfattach.rb'
+require 'tc_pages.rb'
+require 'tc_actions.rb'
+require 'tc_annotations.rb'
+require 'tc_pdfnew.rb'
+
+begin
+  require 'origami'
+rescue LoadError
+  ORIGAMIDIR = "#{File.dirname(__FILE__)}/.."
+  $: << ORIGAMIDIR
+  require 'origami'
+end
+include Origami
+
+ class TS_PdfTests
+   def self.suite
+     suite = Test::Unit::TestSuite.new "PDF test suite"
+     suite << TC_PdfParse.suite
+     suite << TC_PdfNew.suite
+     suite << TC_Streams.suite
+     suite << TC_Pages.suite
+     suite << TC_PdfEncrypt.suite
+     suite << TC_PdfSig.suite
+     suite << TC_PdfAttach.suite
+     suite << TC_Actions.suite
+     suite << TC_Annotations.suite
+     suite
+   end
+ end
+ 
+if ARGV.size > 0 and ARGV[0] == "gtk"
+  require 'test/unit/ui/gtk2/testrunner'
+  Test::Unit::UI::GTK2::TestRunner.run(TS_PdfTests)
+else
+  require 'test/unit/ui/console/testrunner'
+  Test::Unit::UI::Console::TestRunner.run(TS_PdfTests)
+end
+
+exit 0