roo 2.6.0 → 2.7.0

data/test/roo/test_libre_office.rb

@@ -0,0 +1,9 @@
+require "test_helper"
+
+class TestRooOpenOffice < Minitest::Test
+  def test_libre_office
+    oo = Roo::LibreOffice.new(File.join(TESTDIR, "numbers1.ods"))
+    oo.default_sheet = oo.sheets.first
+    assert_equal 41, oo.cell("a", 12)
+  end
+end

data/test/roo/test_open_office.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+require "test_helper"
+
+class TestRooOpenOffice < Minitest::Test
+  def test_openoffice_download_uri_and_zipped
+    port = 12_345
+    file = "rata.ods.zip"
+    start_local_server(file, port) do
+      url = "#{local_server(port)}/#{file}"
+
+      oo = roo_class.new(url, packed: :zip)
+      assert_in_delta 0.001, 505.14, oo.cell("c", 33).to_f
+    end
+  end
+
+  def test_download_uri_with_invalid_host
+    assert_raises(RuntimeError) do
+      roo_class.new("http://example.com/file.ods")
+    end
+  end
+
+  def test_download_uri_with_query_string
+    file = filename("simple_spreadsheet")
+    port = 12_346
+    url = "#{local_server(port)}/#{file}?query-param=value"
+    start_local_server(file, port) do
+      spreadsheet = roo_class.new(url)
+      assert_equal "Task 1", spreadsheet.cell("f", 4)
+    end
+  end
+
+  def test_openoffice_zipped
+    oo = roo_class.new(File.join(TESTDIR, "bode-v1.ods.zip"), packed: :zip)
+    assert oo
+    assert_equal 'ist "e" im Nenner von H(s)', oo.cell("b", 5)
+  end
+
+  def test_should_raise_file_not_found_error
+    assert_raises(IOError) do
+      roo_class.new(File.join("testnichtvorhanden", "Bibelbund.ods"))
+    end
+  end
+
+
+  def test_file_warning_default_is_error
+    expected_message = "test/files/numbers1.xls is not an openoffice spreadsheet"
+    assert_raises(TypeError, expected_message) do
+      roo_class.new(File.join(TESTDIR, "numbers1.xls"))
+    end
+
+    assert_raises(TypeError) do
+      roo_class.new(File.join(TESTDIR, "numbers1.xlsx"))
+    end
+  end
+
+  def test_file_warning_error
+    assert_raises(TypeError) do
+      roo_class.new(File.join(TESTDIR, "numbers1.xls"),
+      packed: false,
+      file_warning: :error
+      )
+    end
+
+    assert_raises(TypeError) do
+      roo_class.new(File.join(TESTDIR, "numbers1.xlsx"),
+      packed: false,
+      file_warning: :error)
+    end
+  end
+
+  def test_file_warning_warning
+    assert_raises(ArgumentError) do
+      roo_class.new(File.join(TESTDIR, "numbers1.xlsx"),
+      packed: false,
+      file_warning: :warning)
+    end
+  end
+
+  def test_file_warning_ignore
+    assert roo_class.new(File.join(TESTDIR, "type_openoffice.xlsx"),
+    packed: false,
+    file_warning: :ignore), "Should not throw an error"
+  end
+
+  def test_encrypted_file
+    oo = roo_class.new(File.join(TESTDIR, "encrypted-letmein.ods"), password: "letmein")
+    assert_equal "Hello World", oo.cell("a", 1)
+  end
+
+  def test_encrypted_file_requires_password
+    assert_raises(ArgumentError) { roo_class.new(File.join(TESTDIR, "encrypted-letmein.ods")) }
+  end
+
+  def test_encrypted_file_with_incorrect_password
+    assert_raises(ArgumentError) { roo_class.new(File.join(TESTDIR, "encrypted-letmein.ods"), password:  "badpassword") }
+  end
+
+  # 2011-08-11
+  def test_bug_openoffice_formula_missing_letters
+    # NOTE: This document was created using LibreOffice. The formulas seem
+    # different from a document created using OpenOffice.
+    #
+    # TODO: translate
+    # Bei den OpenOffice-Dateien ist in diesem Feld in der XML-
+    # Datei of: als Prefix enthalten, waehrend in dieser Datei
+    # irgendetwas mit oooc: als Prefix verwendet wird.
+    oo = Roo::OpenOffice.new(File.join(TESTDIR,'dreimalvier.ods'))
+    assert_equal '=SUM([.A1:.D1])', oo.formula('e',1)
+    assert_equal '=SUM([.A2:.D2])', oo.formula('e',2)
+    assert_equal '=SUM([.A3:.D3])', oo.formula('e',3)
+    assert_equal [
+      [1,5,'=SUM([.A1:.D1])'],
+      [2,5,'=SUM([.A2:.D2])'],
+      [3,5,'=SUM([.A3:.D3])'],
+      ], oo.formulas
+
+  end
+
+  def roo_class
+    Roo::OpenOffice
+  end
+
+  def filename(name)
+    "#{name}.ods"
+  end
+end

data/test/test_helper.rb

@@ -1,19 +1,21 @@
+# encoding: utf-8
 require 'simplecov'
 # require deps
 require 'tmpdir'
 require 'fileutils'
 require 'minitest/autorun'
 require 'shoulda'
-require 'fileutils'
 require 'timeout'
 require 'logger'
 require 'date'
-require 'webmock/minitest'
 
 # require gem files
 require 'roo'
+require "minitest/reporters"
+Minitest::Reporters.use!([Minitest::Reporters::DefaultReporter.new,
+                          Minitest::Reporters::SpecReporter.new]) unless defined? JRUBY_VERSION
 
-TESTDIR =  File.join(File.dirname(__FILE__), 'files')
+TESTDIR = File.join(File.dirname(__FILE__), 'files')
 
 # very simple diff implementation
 # output is an empty string if the files are equal
@@ -52,3 +54,72 @@ class File
     end
   end
 end
+
+def local_server(port)
+  raise ArgumentError unless port.to_i > 0
+  "http://0.0.0.0:#{port}"
+end
+
+def start_local_server(filename, port = nil)
+  require "rack"
+  content_type = filename.split(".").last
+  port ||= TEST_RACK_PORT
+
+  web_server = Proc.new do |env|
+    [
+      "200",
+      { "Content-Type" => content_type },
+      [File.read("#{TESTDIR}/#{filename}")]
+    ]
+  end
+
+  t = Thread.new { Rack::Handler::WEBrick.run web_server, Host: '0.0.0.0', Port: port , Logger: WEBrick::BasicLog.new(nil,1) }
+  # give the app a chance to startup
+  sleep(0.2)
+
+  yield
+ensure
+  t.kill
+end
+
+ROO_FORMATS = [
+  :excelx,
+  :excelxm,
+  :openoffice,
+  :libreoffice
+]
+
+# call a block of code for each spreadsheet type
+# and yield a reference to the roo object
+def with_each_spreadsheet(options)
+  if options[:format]
+    formats = Array(options[:format])
+    invalid_formats = formats - ROO_FORMATS
+    unless invalid_formats.empty?
+      raise "invalid spreadsheet types: #{invalid_formats.join(', ')}"
+    end
+  else
+    formats = ROO_FORMATS
+  end
+  formats.each do |format|
+    begin
+      yield Roo::Spreadsheet.open(File.join(TESTDIR,
+        fixture_filename(options[:name], format)))
+    rescue => e
+      raise e, "#{e.message} for #{format}", e.backtrace unless options[:ignore_errors]
+    end
+  end
+end
+
+def fixture_filename(name, format)
+  case format
+  when :excelx
+    "#{name}.xlsx"
+  when :excelxm
+    "#{name}.xlsm"
+  when :openoffice, :libreoffice
+    "#{name}.ods"
+  else
+    raise ArgumentError, "unexpected format #{format}"
+  end
+end

data/test/test_roo.rb

@@ -1,17 +1,4 @@
 # encoding: utf-8
-# damit keine falschen Vermutungen aufkommen: Ich habe religioes rein gar nichts
-# mit diesem Bibelbund zu tun, aber die hatten eine ziemlich grosse
-# Spreadsheet-Datei mit ca. 3500 Zeilen oeffentlich im Netz, die sich ganz gut
-# zum Testen eignete.
-#
-#--
-# these test cases were developed to run under Linux OS, some commands
-# (like 'diff') must be changed (or commented out ;-)) if you want to run
-# the tests under another OS
-#
-
-#TODO
-# Look at formulas in excel - does not work with date/time
 
 # Dump warnings that come from the test to open files
 # with the wrong spreadsheet class
@@ -23,69 +10,7 @@ require 'test_helper'
 require 'stringio'
 
 class TestRoo < Minitest::Test
-
-  OPENOFFICE   = true   # do OpenOffice-Spreadsheet Tests? (.ods files)
-  EXCELX       = true   # do Excelx Tests? (.xlsx files)
-  LIBREOFFICE  = true   # do LibreOffice tests? (.ods files)
-  CSV          = true   # do CSV tests? (.csv files)
-
-  FORMATS = [
-    :excelx,
-    :excelxm,
-    :openoffice,
-    :libreoffice
-  ]
-
-  ONLINE = false
-  LONG_RUN = false
-
-  def fixture_filename(name, format)
-    case format
-    when :excelx
-      "#{name}.xlsx"
-    when :excelxm
-      "#{name}.xlsm"
-    when :openoffice, :libreoffice
-      "#{name}.ods"
-    else
-      raise ArgumentError, "unexpected format #{format}"
-    end
-  end
-
-  # call a block of code for each spreadsheet type
-  # and yield a reference to the roo object
-  def with_each_spreadsheet(options)
-    if options[:format]
-      formats = Array(options[:format])
-      invalid_formats = formats - FORMATS
-      unless invalid_formats.empty?
-        raise "invalid spreadsheet types: #{invalid_formats.join(', ')}"
-      end
-    else
-      formats = FORMATS
-    end
-    formats.each do |format|
-      begin
-        yield Roo::Spreadsheet.open(File.join(TESTDIR,
-          fixture_filename(options[:name], format)))
-      rescue => e
-        raise e, "#{e.message} for #{format}", e.backtrace unless options[:ignore_errors]
-      end
-    end
-  end
-
-  def test_sheets_csv
-    if CSV
-      oo = Roo::CSV.new(File.join(TESTDIR,'numbers1.csv'))
-      assert_equal ["default"], oo.sheets
-      assert_raises(RangeError) { oo.default_sheet = "no_sheet" }
-      assert_raises(TypeError)  { oo.default_sheet = [1,2,3] }
-      oo.sheets.each { |sh|
-        oo.default_sheet = sh
-        assert_equal sh, oo.default_sheet
-      }
-    end
-  end
+  LONG_RUN = ENV["LONG_RUN"] ? true : false
 
   def test_sheets
     with_each_spreadsheet(:name=>'numbers1') do |oo|
@@ -168,14 +93,6 @@ class TestRoo < Minitest::Test
     end
   end
 
-  def test_libre_office
-    if LIBREOFFICE
-      oo = Roo::LibreOffice.new(File.join(TESTDIR, "numbers1.ods"))
-      oo.default_sheet = oo.sheets.first
-      assert_equal 41, oo.cell('a',12)
-    end
-  end
-
   def test_sheetname
     with_each_spreadsheet(:name=>'numbers1') do |oo|
       oo.default_sheet = "Name of Sheet 2"
@@ -379,25 +296,6 @@ class TestRoo < Minitest::Test
     end
   end
 
-  def test_openoffice_download_uri_and_zipped
-    if OPENOFFICE
-      if ONLINE
-        url = 'http://spazioinwind.libero.it/s2/rata.ods.zip'
-        sheet = Roo::OpenOffice.new(url, packed: :zip)
-        #has been changed: assert_equal 'ist "e" im Nenner von H(s)', sheet.cell('b', 5)
-        assert_in_delta 0.001, 505.14, sheet.cell('c', 33).to_f
-      end
-    end
-  end
-
-  def test_openoffice_zipped
-    if OPENOFFICE
-      oo = Roo::OpenOffice.new(File.join(TESTDIR,"bode-v1.ods.zip"), packed: :zip)
-      assert oo
-      assert_equal 'ist "e" im Nenner von H(s)', oo.cell('b', 5)
-    end
-  end
-
   def test_bug_ric
     with_each_spreadsheet(:name=>'ric', :format=>:openoffice) do |oo|
       assert oo.empty?('A',1)
@@ -447,51 +345,6 @@ class TestRoo < Minitest::Test
     with_each_spreadsheet(:name=>'Bibelbund1', :format=>:openoffice) do |oo|
       assert_equal "Tagebuch des Sekret\303\244rs.    Letzte Tagung 15./16.11.75 Schweiz", oo.cell(45,'A')
     end
-    #if EXCELX
-    #    #Datei gibt es noch nicht
-    #    oo = Roo::Excelx.new(File.join(TESTDIR,"Bibelbund1.xlsx"))
-    #    oo.default_sheet = oo.sheets.first
-    #    assert_equal "Tagebuch des Sekret\303\244rs.    Letzte Tagung 15./16.11.75 Schweiz", oo.cell(45,'A')
-    #end
-  end
-
-  # "/tmp/xxxx" darf man unter Windows nicht verwenden, weil das nicht erkannt
-  # wird.
-  # Besser: Methode um temporaeres Dir. portabel zu bestimmen
-  def test_huge_document_to_csv
-    if LONG_RUN
-      with_each_spreadsheet(:name=>'Bibelbund', :format=>[
-        :openoffice,
-        :excelx
-        # Google hier nicht, weil Google-Spreadsheets nicht so gross werden
-        # duerfen
-      ]) do |oo|
-        Dir.mktmpdir do |tempdir|
-          assert_equal "Tagebuch des Sekret\303\244rs.    Letzte Tagung 15./16.11.75 Schweiz", oo.cell(45,'A')
-          assert_equal "Tagebuch des Sekret\303\244rs.  Nachrichten aus Chile", oo.cell(46,'A')
-          assert_equal "Tagebuch aus Chile  Juli 1977", oo.cell(55,'A')
-          assert oo.to_csv(File.join(tempdir,"Bibelbund.csv"))
-          assert File.exists?(File.join(tempdir,"Bibelbund.csv"))
-          assert_equal "", file_diff(File.join(TESTDIR, "Bibelbund.csv"), File.join(tempdir,"Bibelbund.csv")),
-            "error in class #{oo.class}"
-          #end
-        end
-      end
-    end
-  end
-
-  def test_bug_quotes_excelx
-    if LONG_RUN
-      with_each_spreadsheet(:name=>'Bibelbund', :format=>[:openoffice, :excelx]) do |oo|
-        oo.default_sheet = oo.sheets.first
-        assert_equal 'Einflüsse der neuen Theologie in "de gereformeerde Kerken van Nederland"',
-        oo.cell('a',76)
-        oo.to_csv("csv#{$$}")
-        assert_equal 'Einflüsse der neuen Theologie in "de gereformeerde Kerken van Nederland"',
-        oo.cell('a',78)
-        File.delete_if_exist("csv#{$$}")
-      end
-    end
   end
 
   def test_bug_mehrere_datum
@@ -573,17 +426,6 @@ class TestRoo < Minitest::Test
     end
   end
 
-
-  def test_bug_empty_sheet
-    with_each_spreadsheet(:name=>'formula', :format=>[:openoffice, :excelx]) do |oo|
-      oo.default_sheet = 'Sheet3' # is an empty sheet
-      Dir.mktmpdir do |tempdir|
-        oo.to_csv(File.join(tempdir,"emptysheet.csv"))
-        assert_equal "", `cat #{File.join(tempdir,"emptysheet.csv")}`
-      end
-    end
-  end
-
   def test_find_by_row_huge_document
     if LONG_RUN
       with_each_spreadsheet(:name=>'Bibelbund', :format=>[:openoffice, :excelx]) do |oo|
@@ -718,7 +560,6 @@ class TestRoo < Minitest::Test
     end
   end
 
-
   #TODO: temporaerer Test
   def test_seiten_als_date
     if LONG_RUN
@@ -827,19 +668,6 @@ class TestRoo < Minitest::Test
     end
   end
 
-  def test_should_raise_file_not_found_error
-    if OPENOFFICE
-      assert_raises(IOError) {
-        Roo::OpenOffice.new(File.join('testnichtvorhanden','Bibelbund.ods'))
-      }
-    end
-    if EXCELX
-      assert_raises(IOError) {
-        Roo::Excelx.new(File.join('testnichtvorhanden','Bibelbund.xlsx'))
-      }
-    end
-  end
-
   def test_bug_bbu
     with_each_spreadsheet(:name=>'bbu', :format=>[:openoffice, :excelx]) do |oo|
         assert_equal "File: bbu#{get_extension(oo)}
@@ -875,200 +703,6 @@ Sheet 3:
     end
   end
 
-  def test_date_time_to_csv
-    with_each_spreadsheet(:name=>'time-test') do |oo|
-      Dir.mktmpdir do |tempdir|
-        csv_output = File.join(tempdir,'time_test.csv')
-        assert oo.to_csv(csv_output)
-        assert File.exists?(csv_output)
-        assert_equal "", `diff --strip-trailing-cr #{TESTDIR}/time-test.csv #{csv_output}`
-        # --strip-trailing-cr is needed because the test-file use 0A and
-        # the test on an windows box generates 0D 0A as line endings
-      end
-    end
-  end
-
-  def test_boolean_to_csv
-    with_each_spreadsheet(:name=>'boolean') do |oo|
-      Dir.mktmpdir do |tempdir|
-        csv_output = File.join(tempdir,'boolean.csv')
-        assert oo.to_csv(csv_output)
-        assert File.exists?(csv_output)
-        assert_equal "", `diff --strip-trailing-cr #{TESTDIR}/boolean.csv #{csv_output}`
-        # --strip-trailing-cr is needed because the test-file use 0A and
-        # the test on an windows box generates 0D 0A as line endings
-      end
-    end
-  end
-  def test_link_to_csv
-    with_each_spreadsheet(:name=>'link',:format=>:excelx) do |oo|
-      Dir.mktmpdir do |tempdir|
-        csv_output = File.join(tempdir,'link.csv')
-        assert oo.to_csv(csv_output)
-        assert File.exists?(csv_output)
-        assert_equal "", `diff --strip-trailing-cr #{TESTDIR}/link.csv #{csv_output}`
-        # --strip-trailing-cr is needed because the test-file use 0A and
-        # the test on an windows box generates 0D 0A as line endings
-      end
-    end
-  end
-  def test_date_time_yaml
-    with_each_spreadsheet(:name=>'time-test') do |oo|
-      expected =
-        "--- \ncell_1_1: \n  row: 1 \n  col: 1 \n  celltype: string \n  value: Mittags: \ncell_1_2: \n  row: 1 \n  col: 2 \n  celltype: time \n  value: 12:13:14 \ncell_1_3: \n  row: 1 \n  col: 3 \n  celltype: time \n  value: 15:16:00 \ncell_1_4: \n  row: 1 \n  col: 4 \n  celltype: time \n  value: 23:00:00 \ncell_2_1: \n  row: 2 \n  col: 1 \n  celltype: date \n  value: 2007-11-21 \n"
-      assert_equal expected, oo.to_yaml
-    end
-  end
-
-  # Erstellt eine Liste aller Zellen im Spreadsheet. Dies ist nötig, weil ein einfacher
-  # Textvergleich des XML-Outputs nicht funktioniert, da xml-builder die Attribute
-  # nicht immer in der gleichen Reihenfolge erzeugt.
-  def init_all_cells(oo,sheet)
-    all = []
-    oo.first_row(sheet).upto(oo.last_row(sheet)) do |row|
-      oo.first_column(sheet).upto(oo.last_column(sheet)) do |col|
-        unless oo.empty?(row,col,sheet)
-          all << {:row => row.to_s,
-            :column => col.to_s,
-            :content => oo.cell(row,col,sheet).to_s,
-            :type => oo.celltype(row,col,sheet).to_s,
-          }
-        end
-      end
-    end
-    all
-  end
-
-  def test_to_xml
-    with_each_spreadsheet(:name=>'numbers1', :encoding => 'utf8') do |oo|
-      skip if defined? JRUBY_VERSION
-      oo.to_xml
-      sheetname = oo.sheets.first
-      doc = Nokogiri::XML(oo.to_xml)
-      sheet_count = 0
-      doc.xpath('//spreadsheet/sheet').each {|tmpelem|
-        sheet_count += 1
-      }
-      assert_equal 5, sheet_count
-      doc.xpath('//spreadsheet/sheet').each { |xml_sheet|
-        all_cells = init_all_cells(oo, sheetname)
-        x = 0
-        assert_equal sheetname, xml_sheet.attributes['name'].value
-        xml_sheet.children.each {|cell|
-          if cell.attributes['name']
-            expected = [all_cells[x][:row],
-              all_cells[x][:column],
-              all_cells[x][:content],
-              all_cells[x][:type],
-            ]
-            result = [
-              cell.attributes['row'],
-              cell.attributes['column'],
-              cell.content,
-              cell.attributes['type'],
-            ]
-            assert_equal expected, result
-            x += 1
-          end # if
-        } # end of sheet
-        sheetname = oo.sheets[oo.sheets.index(sheetname)+1]
-      }
-    end
-  end
-
-  def test_file_warning_default
-    if OPENOFFICE
-      assert_raises(TypeError, "test/files/numbers1.xls is not an openoffice spreadsheet") {
-        Roo::OpenOffice.new(File.join(TESTDIR,"numbers1.xls"))
-      }
-      assert_raises(TypeError) { Roo::OpenOffice.new(File.join(TESTDIR,"numbers1.xlsx")) }
-    end
-    if EXCELX
-      assert_raises(TypeError) { Roo::Excelx.new(File.join(TESTDIR,"numbers1.ods")) }
-      assert_raises(TypeError) { Roo::Excelx.new(File.join(TESTDIR,"numbers1.xls")) }
-    end
-  end
-
-  def test_file_warning_error
-    if OPENOFFICE
-      assert_raises(TypeError) {
-        Roo::OpenOffice.new(File.join(TESTDIR,"numbers1.xls"),
-          packed: false,
-          file_warning: :error
-        )
-      }
-      assert_raises(TypeError) {
-        Roo::OpenOffice.new(File.join(TESTDIR,"numbers1.xlsx"),
-          packed: false,
-          file_warning: :error)
-      }
-    end
-    if EXCELX
-      assert_raises(TypeError) {
-        Roo::Excelx.new(File.join(TESTDIR,"numbers1.ods"),
-          packed: false,
-          file_warning: :error)
-      }
-      assert_raises(TypeError) {
-        Roo::Excelx.new(File.join(TESTDIR,"numbers1.xls"),
-          packed: false,
-          file_warning: :error)
-      }
-    end
-  end
-
-  def test_file_warning_warning
-    if OPENOFFICE
-      assert_raises(ArgumentError) {
-        Roo::OpenOffice.new(File.join(TESTDIR,"numbers1.xlsx"),
-        packed: false,
-        file_warning: :warning)
-      }
-    end
-    if EXCELX
-      assert_raises(ArgumentError) {
-        Roo::Excelx.new(File.join(TESTDIR,"numbers1.ods"),
-        packed: false,
-        file_warning: :warning)
-      }
-    end
-  end
-
-  def test_file_warning_ignore
-    if OPENOFFICE
-      # Files, die eigentlich OpenOffice-
-      # Files sind, aber die falsche Endung haben.
-      # Es soll ohne Fehlermeldung oder Warnung
-      # oder Abbruch die Datei geoffnet werden
-
-      # xlsx
-        Roo::OpenOffice.new(File.join(TESTDIR,"type_openoffice.xlsx"),
-          packed: false,
-          file_warning: :ignore)
-    end
-    if EXCELX
-        Roo::Excelx.new(File.join(TESTDIR,"type_excelx.ods"),
-          packed: false,
-          file_warning: :ignore)
-    end
-  end
-
-  def test_bug_to_xml_with_empty_sheets
-    with_each_spreadsheet(:name=>'emptysheets', :format=>[:openoffice, :excelx]) do |oo|
-      oo.sheets.each { |sheet|
-        assert_nil oo.first_row, "first_row not nil in sheet #{sheet}"
-        assert_nil oo.last_row, "last_row not nil in sheet #{sheet}"
-        assert_nil oo.first_column, "first_column not nil in sheet #{sheet}"
-        assert_nil oo.last_column, "last_column not nil in sheet #{sheet}"
-        assert_nil oo.first_row(sheet), "first_row not nil in sheet #{sheet}"
-        assert_nil oo.last_row(sheet), "last_row not nil in sheet #{sheet}"
-        assert_nil oo.first_column(sheet), "first_column not nil in sheet #{sheet}"
-        assert_nil oo.last_column(sheet), "last_column not nil in sheet #{sheet}"
-      }
-      oo.to_xml
-    end
-  end
-
   def test_bug_simple_spreadsheet_time_bug
     # really a bug? are cells really of type time?
     # No! :float must be the correct type
@@ -1324,7 +958,6 @@ Sheet 3:
     end
   end
 
-
   # compare large spreadsheets
   def test_compare_large_spreadsheets
     # problematisch, weil Formeln in Excel nicht unterstützt werden
@@ -1446,95 +1079,6 @@ Sheet 3:
      end
    end
 
-  require 'matrix'
-  def test_matrix
-    with_each_spreadsheet(:name => 'matrix', :format => :openoffice) do |oo|
-      oo.default_sheet = oo.sheets.first
-      assert_equal Matrix[
-        [1.0, 2.0, 3.0],
-        [4.0, 5.0, 6.0],
-        [7.0, 8.0, 9.0] ], oo.to_matrix
-    end
-  end
-
-  def test_matrix_selected_range
-    with_each_spreadsheet(:name => 'matrix', :format=>:openoffice) do |oo|
-      oo.default_sheet = 'Sheet2'
-      assert_equal Matrix[
-        [1.0, 2.0, 3.0],
-        [4.0, 5.0, 6.0],
-        [7.0, 8.0, 9.0] ], oo.to_matrix(3,4,5,6)
-    end
-  end
-
-  def test_matrix_all_nil
-    with_each_spreadsheet(:name => 'matrix', :format=>:openoffice) do |oo|
-      oo.default_sheet = 'Sheet2'
-      assert_equal Matrix[
-        [nil, nil, nil],
-        [nil, nil, nil],
-        [nil, nil, nil] ], oo.to_matrix(10,10,12,12)
-    end
-  end
-
-  def test_matrix_values_and_nil
-    with_each_spreadsheet(:name => 'matrix', :format=>:openoffice) do |oo|
-      oo.default_sheet = 'Sheet3'
-      assert_equal Matrix[
-        [1.0, nil, 3.0],
-        [4.0, 5.0, 6.0],
-        [7.0, 8.0, nil] ], oo.to_matrix(1,1,3,3)
-    end
-  end
-
-  def test_matrix_specifying_sheet
-    with_each_spreadsheet(:name => 'matrix', :format => :openoffice) do |oo|
-      oo.default_sheet = oo.sheets.first
-      assert_equal Matrix[
-        [1.0, nil, 3.0],
-        [4.0, 5.0, 6.0],
-        [7.0, 8.0, nil] ], oo.to_matrix(nil, nil, nil, nil, 'Sheet3')
-    end
-  end
-
-  # unter Windows soll es laut Bug-Reports nicht moeglich sein, eine Excel-Datei, die
-  # mit Excel.new geoeffnet wurde nach dem Processing anschliessend zu loeschen.
-  # Anmerkung: Das Spreadsheet-Gem erlaubt kein explizites Close von Spreadsheet-Dateien,
-  # was verhindern koennte, das die Datei geloescht werden kann.
-  # def test_bug_cannot_delete_opened_excel_sheet
-  #   with_each_spreadsheet(:name=>'simple_spreadsheet') do |oo|
-  #     'kopiere  nach temporaere Datei und versuche diese zu oeffnen und zu loeschen'
-  #   end
-  # end
-
-  def test_bug_xlsx_reference_cell
-
-    if EXCELX
-=begin
-    If cell A contains a string and cell B references cell A.  When reading the value of cell B, the result will be
-"0.0" instead of the value of cell A.
-
-With the attached test case, I ran the following code:
-spreadsheet = Roo::Excelx.new('formula_string_error.xlsx')
-spreadsheet.default_sheet = 'sheet1'
-p "A: #{spreadsheet.cell(1, 1)}"
-p "B: #{spreadsheet.cell(2, 1)}"
-
-with the following results
-"A: TestString"
-"B: 0.0"
-
-where the expected result is
-"A: TestString"
-"B: TestString"
-=end
-      xlsx = Roo::Excelx.new(File.join(TESTDIR, "formula_string_error.xlsx"))
-      xlsx.default_sheet = xlsx.sheets.first
-      assert_equal 'Teststring', xlsx.cell('a',1)
-      assert_equal 'Teststring', xlsx.cell('a',2)
-    end
-  end
-
   # #formulas of an empty sheet should return an empty array and not result in
   # an error message
   # 2011-06-24
@@ -1547,116 +1091,6 @@ where the expected result is
     end
   end
 
-  # #to_yaml of an empty sheet should return an empty string and not result in
-  # an error message
-  # 2011-06-24
-  def test_bug_to_yaml_empty_sheet
-    with_each_spreadsheet(:name =>'emptysheets',
-      :format=>[:openoffice,:excelx]) do |oo|
-        oo.default_sheet = oo.sheets.first
-        oo.to_yaml
-      assert_equal('', oo.to_yaml)
-    end
-  end
-
-  # #to_matrix of an empty sheet should return an empty matrix and not result in
-  # an error message
-  # 2011-06-25
-  def test_bug_to_matrix_empty_sheet
-    with_each_spreadsheet(:name =>'emptysheets',
-      :format=>[:openoffice,:excelx]) do |oo|
-        oo.default_sheet = oo.sheets.first
-        oo.to_matrix
-      assert_equal(Matrix.empty(0,0), oo.to_matrix)
-    end
-  end
-
-  # 2011-08-03
-  def test_bug_datetime_to_csv
-    with_each_spreadsheet(:name=>'datetime') do |oo|
-      Dir.mktmpdir do |tempdir|
-        datetime_csv_file = File.join(tempdir,"datetime.csv")
-
-        assert oo.to_csv(datetime_csv_file)
-        assert File.exists?(datetime_csv_file)
-        assert_equal "", file_diff('test/files/so_datetime.csv', datetime_csv_file)
-      end
-    end
-  end
-
-  # 2011-08-11
-  def test_bug_openoffice_formula_missing_letters
-    if LIBREOFFICE
-      # Dieses Dokument wurde mit LibreOffice angelegt.
-      # Keine Ahnung, ob es damit zusammenhaengt, das diese
-      # Formeln anders sind, als in der Datei formula.ods, welche
-      # mit OpenOffice angelegt wurde.
-      # Bei den OpenOffice-Dateien ist in diesem Feld in der XML-
-      # Datei of: als Prefix enthalten, waehrend in dieser Datei
-      # irgendetwas mit oooc: als Prefix verwendet wird.
-      oo = Roo::OpenOffice.new(File.join(TESTDIR,'dreimalvier.ods'))
-      oo.default_sheet = oo.sheets.first
-      assert_equal '=SUM([.A1:.D1])', oo.formula('e',1)
-      assert_equal '=SUM([.A2:.D2])', oo.formula('e',2)
-      assert_equal '=SUM([.A3:.D3])', oo.formula('e',3)
-      assert_equal [
-       [1,5,'=SUM([.A1:.D1])'],
-        [2,5,'=SUM([.A2:.D2])'],
-        [3,5,'=SUM([.A3:.D3])'],
-      ], oo.formulas
-
-    end
-  end
-
-=begin
-  def test_postprocessing_and_types_in_csv
-    if CSV
-      oo = CSV.new(File.join(TESTDIR,'csvtypes.csv'))
-      oo.default_sheet = oo.sheets.first
-      assert_equal(1,oo.a1)
-      assert_equal(:float,oo.celltype('A',1))
-      assert_equal("2",oo.b1)
-      assert_equal(:string,oo.celltype('B',1))
-      assert_equal("Mayer",oo.c1)
-      assert_equal(:string,oo.celltype('C',1))
-    end
-  end
-=end
-
-=begin
-  def test_postprocessing_with_callback_function
-    if CSV
-      oo = CSV.new(File.join(TESTDIR,'csvtypes.csv'))
-      oo.default_sheet = oo.sheets.first
-
-      #
-      assert_equal(1, oo.last_column)
-    end
-  end
-=end
-
-=begin
-  def x_123
-  class ::CSV
-    def cell_postprocessing(row,col,value)
-      if row < 3
-        return nil
-      end
-      return value
-    end
-  end
-  end
-=end
-
-  def test_nil_rows_and_lines_csv
-    # x_123
-    if CSV
-      oo = Roo::CSV.new(File.join(TESTDIR,'Bibelbund.csv'))
-      oo.default_sheet = oo.sheets.first
-      assert_equal 1, oo.first_row
-    end
-  end
-
   def test_bug_pfand_from_windows_phone_xlsx
     return if defined? JRUBY_VERSION
     with_each_spreadsheet(:name=>'Pfand_from_windows_phone', :format=>:excelx) do |oo|
@@ -1707,50 +1141,6 @@ where the expected result is
     end
   end
 
-  ## PREVIOUSLY SKIPPED
-
-  # don't have these test files so removing. We can easily add in
-  # by modifying with_each_spreadsheet
-  GNUMERIC_ODS = false  # do gnumeric with ods files Tests?
-  OPENOFFICEWRITE = false # experimental: write access with OO-Documents
-
-  def test_writeopenoffice
-    if OPENOFFICEWRITE
-      File.cp(File.join(TESTDIR,"numbers1.ods"),
-        File.join(TESTDIR,"numbers2.ods"))
-      File.cp(File.join(TESTDIR,"numbers2.ods"),
-        File.join(TESTDIR,"bak_numbers2.ods"))
-      oo = OpenOffice.new(File.join(TESTDIR,"numbers2.ods"))
-      oo.default_sheet = oo.sheets.first
-      oo.first_row.upto(oo.last_row) {|y|
-        oo.first_column.upto(oo.last_column) {|x|
-          unless oo.empty?(y,x)
-            # oo.set(y, x, oo.cell(y,x) + 7) if oo.celltype(y,x) == "float"
-            oo.set(y, x, oo.cell(y,x) + 7) if oo.celltype(y,x) == :float
-          end
-        }
-      }
-      oo.save
-
-      oo1 = Roo::OpenOffice.new(File.join(TESTDIR,"numbers2.ods"))
-      oo2 = Roo::OpenOffice.new(File.join(TESTDIR,"bak_numbers2.ods"))
-      #p oo2.to_s
-      assert_equal 999, oo2.cell('a',1), oo2.cell('a',1)
-      assert_equal oo2.cell('a',1) + 7, oo1.cell('a',1)
-      assert_equal oo2.cell('b',1)+7, oo1.cell('b',1)
-      assert_equal oo2.cell('c',1)+7, oo1.cell('c',1)
-      assert_equal oo2.cell('d',1)+7, oo1.cell('d',1)
-      assert_equal oo2.cell('a',2)+7, oo1.cell('a',2)
-      assert_equal oo2.cell('b',2)+7, oo1.cell('b',2)
-      assert_equal oo2.cell('c',2)+7, oo1.cell('c',2)
-      assert_equal oo2.cell('d',2)+7, oo1.cell('d',2)
-      assert_equal oo2.cell('e',2)+7, oo1.cell('e',2)
-
-      File.cp(File.join(TESTDIR,"bak_numbers2.ods"),
-        File.join(TESTDIR,"numbers2.ods"))
-    end
-  end
-
   def common_possible_bug_snowboard_cells(ss)
     assert_equal "A.", ss.cell(13,'A'), ss.class
     assert_equal 147, ss.cell(13,'f'), ss.class
@@ -1766,323 +1156,12 @@ where the expected result is
     assert_equal "168W", ss.cell(13,'o'), ss.class
   end
 
-  # def test_false_encoding
-  #   ex = Roo::Excel.new(File.join(TESTDIR,'false_encoding.xls'))
-  #   ex.default_sheet = ex.sheets.first
-  #   assert_equal "Sheet1", ex.sheets.first
-  #   ex.first_row.upto(ex.last_row) do |row|
-  #     ex.first_column.upto(ex.last_column) do |col|
-  #       content = ex.cell(row,col)
-  #       puts "#{row}/#{col}"
-  #       #puts content if ! ex.empty?(row,col) or ex.formula?(row,col)
-  #       if ex.formula?(row,col)
-  #         #! ex.empty?(row,col)
-  #         puts content
-  #       end
-  #     end
-  #   end
-  # end
-
-  def test_download_uri
-    if ONLINE
-      if OPENOFFICE
-        assert_raises(RuntimeError) {
-          Roo::OpenOffice.new("http://gibbsnichtdomainxxxxx.com/file.ods")
-        }
-      end
-      if EXCELX
-        assert_raises(RuntimeError) {
-          Roo::Excelx.new("http://gibbsnichtdomainxxxxx.com/file.xlsx")
-        }
-      end
-    end
-  end
-
-  def test_download_uri_with_query_string
-    dir = File.expand_path("#{File.dirname __FILE__}/files")
-    { xlsx: [EXCELX,      Roo::Excelx],
-      ods:  [OPENOFFICE,  Roo::OpenOffice]}.each do |extension, (flag, type)|
-        if flag
-          file = "#{dir}/simple_spreadsheet.#{extension}"
-          url = "http://test.example.com/simple_spreadsheet.#{extension}?query-param=value"
-          stub_request(:any, url).to_return(body: File.read(file))
-          spreadsheet = type.new(url)
-          spreadsheet.default_sheet = spreadsheet.sheets.first
-          assert_equal 'Task 1', spreadsheet.cell('f', 4)
-        end
-      end
-  end
-
-  # def test_soap_server
-  #   #threads = []
-  #   #threads << Thread.new("serverthread") do
-  #   fork do
-  #     p "serverthread started"
-  #     puts "in child, pid = #$$"
-  #     puts `/usr/bin/ruby rooserver.rb`
-  #     p "serverthread finished"
-  #   end
-  #   #threads << Thread.new("clientthread") do
-  #   p "clientthread started"
-  #   sleep 10
-  #   proxy = SOAP::RPC::Driver.new("http://localhost:12321","spreadsheetserver")
-  #   proxy.add_method('cell','row','col')
-  #   proxy.add_method('officeversion')
-  #   proxy.add_method('last_row')
-  #   proxy.add_method('last_column')
-  #   proxy.add_method('first_row')
-  #   proxy.add_method('first_column')
-  #   proxy.add_method('sheets')
-  #   proxy.add_method('set_default_sheet','s')
-  #   proxy.add_method('ferien_fuer_region', 'region')
-
-  #   sheets = proxy.sheets
-  #   p sheets
-  #   proxy.set_default_sheet(sheets.first)
-
-  #   assert_equal 1, proxy.first_row
-  #   assert_equal 1, proxy.first_column
-  #   assert_equal 187, proxy.last_row
-  #   assert_equal 7, proxy.last_column
-  #   assert_equal 42, proxy.cell('C',8)
-  #   assert_equal 43, proxy.cell('F',12)
-  #   assert_equal "1.0", proxy.officeversion
-  #   p "clientthread finished"
-  #   #end
-  #   #threads.each {|t| t.join }
-  #   puts "fertig"
-  #   Process.kill("INT",pid)
-  #   pid = Process.wait
-  #   puts "child terminated, pid= #{pid}, status= #{$?.exitstatus}"
-  # end
-
-  def split_coord(s)
-    letter = ""
-    number = 0
-    i = 0
-    while i<s.length and "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".include?(s[i,1])
-      letter += s[i,1]
-      i+=1
-    end
-    while i<s.length and "01234567890".include?(s[i,1])
-      number = number*10 + s[i,1].to_i
-      i+=1
-    end
-    if letter=="" or number==0
-      raise ArgumentError
-    end
-    return letter,number
-  end
-
-  #def sum(s,expression)
-  #  arg = expression.split(':')
-  #  b,z = split_coord(arg[0])
-  #  first_row = z
-  #  first_col = OpenOffice.letter_to_number(b)
-  #  b,z = split_coord(arg[1])
-  #  last_row = z
-  #  last_col = OpenOffice.letter_to_number(b)
-  #  result = 0
-  #  first_row.upto(last_row) {|row|
-  #    first_col.upto(last_col) {|col|
-  #      result = result + s.cell(row,col)
-  #    }
-  #  }
-  #  result
-  #end
-
-  #def test_dsl
-  #  s = OpenOffice.new(File.join(TESTDIR,"numbers1.ods"))
-  #  s.default_sheet = s.sheets.first
-  #
-  #    s.set 'a',1, 5
-  #    s.set 'b',1, 3
-  #    s.set 'c',1, 7
-  #    s.set('a',2, s.cell('a',1)+s.cell('b',1))
-  #    assert_equal 8, s.cell('a',2)
-  #
-  #    assert_equal 15, sum(s,'A1:C1')
-  #  end
-
-  #def test_create_spreadsheet1
-  #  name = File.join(TESTDIR,'createdspreadsheet.ods')
-  #  rm(name) if File.exists?(File.join(TESTDIR,'createdspreadsheet.ods'))
-  #  # anlegen, falls noch nicht existierend
-  #  s = OpenOffice.new(name,true)
-  #  assert File.exists?(name)
-  #end
-
-  #def test_create_spreadsheet2
-  #  # anlegen, falls noch nicht existierend
-  #  s = OpenOffice.new(File.join(TESTDIR,"createdspreadsheet.ods"),true)
-  #  s.set 'a',1,42
-  #  s.set 'b',1,43
-  #  s.set 'c',1,44
-  #  s.save
-  #
-  #  t = OpenOffice.new(File.join(TESTDIR,"createdspreadsheet.ods"))
-  #  assert_equal 42, t.cell(1,'a')
-  #  assert_equal 43, t.cell('b',1)
-  #  assert_equal 44, t.cell('c',3)
-  #end
-
-  # We don't have the bode-v1.xlsx test file
-  # #TODO: xlsx-Datei anpassen!
-  # def test_excelx_download_uri_and_zipped
-  #   #TODO: gezippte xlsx Datei online zum Testen suchen
-  #   if EXCELX
-  #     if ONLINE
-  #       url = 'http://stiny-leonhard.de/bode-v1.xlsx.zip'
-  #       excel = Roo::Excelx.new(url, :zip)
-  #       assert_equal 'ist "e" im Nenner von H(s)', excel.cell('b', 5)
-  #     end
-  #   end
-  # end
-
-  # def test_excelx_zipped
-  #   # TODO: bode...xls bei Gelegenheit nach .xlsx konverieren lassen und zippen!
-  #   if EXCELX
-  #     # diese Datei gibt es noch nicht gezippt
-  #     excel = Roo::Excelx.new(File.join(TESTDIR,"bode-v1.xlsx.zip"), :zip)
-  #     assert excel
-  #     assert_raises(ArgumentError) {
-  #       assert_equal 'ist "e" im Nenner von H(s)', excel.cell('b', 5)
-  #     }
-  #     excel.default_sheet = excel.sheets.first
-  #     assert_equal 'ist "e" im Nenner von H(s)', excel.cell('b', 5)
-  #   end
-  # end
-
-  def test_csv_parsing_with_headers
-    return unless CSV
-    headers = ["TITEL", "VERFASSER", "OBJEKT", "NUMMER", "SEITE", "INTERNET", "PC", "KENNUNG"]
-
-    oo = Roo::Spreadsheet.open(File.join(TESTDIR, 'Bibelbund.csv'))
-    parsed = oo.parse(:headers => true)
-    assert_equal headers, parsed[1].keys
-  end
-
   def test_bug_numbered_sheet_names
     with_each_spreadsheet(:name=>'bug-numbered-sheet-names', :format=>:excelx) do |oo|
       oo.each_with_pagename { }
     end
   end
 
-  def test_parsing_xslx_from_numbers
-    return unless EXCELX
-    xlsx  = Roo::Excelx.new(File.join(TESTDIR, "numbers-export.xlsx"))
-
-    xlsx.default_sheet = xlsx.sheets.first
-    assert_equal 'Sheet 1', xlsx.cell('a',1)
-
-    # Another buggy behavior of Numbers 3.1: if a warkbook has more than a
-    # single sheet, all sheets except the first one will have an extra row and
-    # column added to the beginning. That's why we assert against cell B2 and
-    # not A1
-    xlsx.default_sheet = xlsx.sheets.last
-    assert_equal 'Sheet 2', xlsx.cell('b',2)
-  end
-
-  def test_openoffice_encryption
-    if OPENOFFICE
-      assert_raises(ArgumentError) { Roo::LibreOffice.new(File.join(TESTDIR, "encrypted-letmein.ods")) }
-      assert_raises(ArgumentError) { Roo::LibreOffice.new(File.join(TESTDIR, "encrypted-letmein.ods"), :password => "badpassword") }
-      oo = Roo::LibreOffice.new(File.join(TESTDIR, "encrypted-letmein.ods"), :password => "letmein")
-      oo.default_sheet = oo.sheets.first
-      assert_equal "Hello World", oo.cell('a',1)
-    end
-  end
-
-  def test_expand_merged_range
-    return unless EXCELX
-    xlsx  = Roo::Excelx.new(File.join(TESTDIR, "merged_ranges.xlsx"), {:expand_merged_ranges => true})
-    for row in 3..7 do
-      for col in 'a'..'b'
-        if row > 3 && row < 7 && col == 'a'
-          assert_equal 'vertical1', xlsx.cell(col,row)
-        else
-          assert_nil xlsx.cell(col,row)
-        end
-      end
-    end
-    for row in 3..11 do
-      for col in 'f'..'h'
-        if row > 3 && row < 11 && col == 'g'
-          assert_equal 'vertical2', xlsx.cell(col,row)
-        else
-          assert_nil xlsx.cell(col,row)
-        end
-      end
-    end
-    for row in 3..5 do
-      for col in 'b'..'f'
-        if row == 4 && col > 'b' && col < 'f'
-          assert_equal 'horizontal', xlsx.cell(col,row)
-        else
-          assert_nil xlsx.cell(col,row)
-        end
-      end
-    end
-    for row in 8..13 do
-      for col in 'a'..'e'
-        if row > 8 && row < 13 && col > 'a' && col < 'e'
-          assert_equal 'block', xlsx.cell(col,row)
-        else
-          assert_nil xlsx.cell(col,row)
-        end
-      end
-    end
-  end
-
-  def test_noexpand_merged_range
-    return unless EXCELX
-    xlsx  = Roo::Excelx.new(File.join(TESTDIR, "merged_ranges.xlsx"))
-    for row in 3..7 do
-      for col in 'a'..'b'
-        if row == 4 && col == 'a'
-          assert_equal 'vertical1', xlsx.cell(col,row)
-        else
-          assert_nil xlsx.cell(col,row)
-        end
-      end
-    end
-    for row in 3..11 do
-      for col in 'f'..'h'
-        if row == 4 && col == 'g'
-          assert_equal 'vertical2', xlsx.cell(col,row)
-        else
-          assert_nil xlsx.cell(col,row)
-        end
-      end
-    end
-    for row in 3..5 do
-      for col in 'b'..'f'
-        if row == 4 && col == 'c'
-          assert_equal 'horizontal', xlsx.cell(col,row)
-        else
-          assert_nil xlsx.cell(col,row)
-        end
-      end
-    end
-    for row in 8..13 do
-      for col in 'a'..'e'
-        if row == 9 && col == 'b'
-          assert_equal 'block', xlsx.cell(col,row)
-        else
-          assert_nil xlsx.cell(col,row)
-        end
-      end
-    end
-  end
-
-  def test_open_stream
-    return unless EXCELX
-    file_contents = File.read File.join(TESTDIR, fixture_filename(:numbers1, :excelx)), encoding: 'BINARY'
-    stream = StringIO.new(file_contents)
-    xlsx = Roo::Excelx.new(stream)
-    assert_equal ["Tabelle1","Name of Sheet 2","Sheet3","Sheet4","Sheet5"], xlsx.sheets
-  end
-
   def test_close
     with_each_spreadsheet(:name=>'numbers1') do |oo|
       next unless (tempdir = oo.instance_variable_get('@tmpdir'))
@@ -2091,16 +1170,31 @@ where the expected result is
     end
   end
 
+  # NOTE: Ruby 2.4.0 changed the way GC works. The last Roo object created by
+  #       with_each_spreadsheet wasn't getting GC'd until after the process
+  #       ended.
+  #
+  #       That behavior change broke this test. In order to fix it, I forked the
+  #       process and passed the temp directories from the forked process in
+  #       order to check if they were removed properly.
   def test_finalize
-    tempdirs = []
-    begin
-      with_each_spreadsheet(:name=>'numbers1') do |oo|
-        tempdirs << oo.instance_variable_get('@tmpdir')
+    skip if defined? JRUBY_VERSION
+
+    read, write = IO.pipe
+    pid = Process.fork do
+      with_each_spreadsheet(name: "numbers1") do |oo|
+        write.puts oo.instance_variable_get("@tmpdir")
       end
-      GC.start
     end
+
+    Process.wait(pid)
+    write.close
+    tempdirs = read.read.split("\n")
+    read.close
+
+    refute tempdirs.empty?
     tempdirs.each do |tempdir|
-      assert !File.exists?(tempdir), "Expected #{tempdir} to be cleaned up, but it still exists"
+      refute File.exist?(tempdir), "Expected #{tempdir} to be cleaned up, but it still exists"
     end
   end