roo 2.0.1 → 2.7.1

data/test/excelx/cell/test_base.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+class TestRooExcelxCellBase < Minitest::Test
+  def base
+    Roo::Excelx::Cell::Base
+  end
+
+  def value
+    'Hello World'
+  end
+
+  def test_cell_type_is_base
+    cell = base.new(value, nil, [], nil, nil, nil)
+    assert_equal :base, cell.type
+  end
+
+  def test_cell_value
+    cell_value = value
+    cell = base.new(cell_value, nil, [], nil, nil, nil)
+    assert_equal cell_value, cell.cell_value
+  end
+
+  def test_not_empty?
+    cell = base.new(value, nil, [], nil, nil, nil)
+    refute cell.empty?
+  end
+
+  def test_cell_type_is_formula
+    formula = true
+    cell = base.new(value, formula, [], nil, nil, nil)
+    assert_equal :formula, cell.type
+  end
+
+  def test_formula?
+    formula = true
+    cell = base.new(value, formula, [], nil, nil, nil)
+    assert cell.formula?
+  end
+
+  def test_cell_type_is_link
+    link = 'http://example.com'
+    cell = base.new(value, nil, [], nil, link, nil)
+    assert_equal :link, cell.type
+  end
+
+  def test_link?
+    link = 'http://example.com'
+    cell = base.new(value, nil, [], nil, link, nil)
+    assert cell.link?
+  end
+
+  def test_link_value
+    link = 'http://example.com'
+    cell = base.new(value, nil, [], nil, link, nil)
+    assert_equal value, cell.value
+  end
+
+  def test_link_value_href
+    link = 'http://example.com'
+    cell = base.new(value, nil, [], nil, link, nil)
+    assert_equal link, cell.value.href
+  end
+end

data/test/excelx/cell/test_boolean.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class TestRooExcelxCellNumber < Minitest::Test
+  def boolean
+    Roo::Excelx::Cell::Boolean
+  end
+
+  def test_formatted_value
+    cell = boolean.new '1', nil, nil, nil, nil
+    assert_equal 'TRUE', cell.formatted_value
+
+    cell = boolean.new '0', nil, nil, nil, nil
+    assert_equal 'FALSE', cell.formatted_value
+  end
+
+  def test_to_s
+    cell = boolean.new '1', nil, nil, nil, nil
+    assert_equal 'TRUE', cell.to_s
+
+    cell = boolean.new '0', nil, nil, nil, nil
+    assert_equal 'FALSE', cell.to_s
+  end
+
+  def test_cell_value
+    cell = boolean.new '1', nil, nil, nil, nil
+    assert_equal '1', cell.cell_value
+  end
+
+  def test_value
+    cell = boolean.new '1', nil, nil, nil, nil
+    assert_equal true, cell.value
+
+    cell = boolean.new '0', nil, nil, nil, nil
+    assert_equal false, cell.value
+  end
+end

data/test/excelx/cell/test_date.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class TestRooExcelxCellDate < Minitest::Test
+  def date_cell
+    Roo::Excelx::Cell::Date
+  end
+
+  def base_date
+    ::Date.new(1899, 12, 30)
+  end
+
+  def base_date_1904
+    ::Date.new(1904, 01, 01)
+  end
+
+  def test_handles_1904_base_date
+    cell = date_cell.new('41791', nil, [:numeric_or_formula, 'mm-dd-yy'], 6, nil, base_date_1904, nil)
+    assert_equal ::Date.new(2018, 06, 02), cell.value
+  end
+
+  def test_formatted_value
+    cell = date_cell.new('41791', nil, [:numeric_or_formula, 'mm-dd-yy'], 6, nil, base_date, nil)
+    assert_equal '06-01-14', cell.formatted_value
+
+    cell = date_cell.new('41791', nil, [:numeric_or_formula, 'yyyy-mm-dd'], 6, nil, base_date, nil)
+    assert_equal '2014-06-01', cell.formatted_value
+  end
+
+  def test_value_is_date
+    cell = date_cell.new('41791', nil, [:numeric_or_formula, 'mm-dd-yy'], 6, nil, base_date, nil)
+    assert_kind_of ::Date, cell.value
+  end
+
+  def test_value
+    cell = date_cell.new('41791', nil, [:numeric_or_formula, 'mm-dd-yy'], 6, nil, base_date, nil)
+    assert_equal ::Date.new(2014, 06, 01), cell.value
+  end
+end

data/test/excelx/cell/test_datetime.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class TestRooExcelxCellDateTime < Minitest::Test
+  def test_cell_value_is_datetime
+    cell = datetime.new('30000.323212', nil, ['mm-dd-yy'], nil, nil, base_date, nil)
+    assert_kind_of ::DateTime, cell.value
+  end
+
+  def test_cell_type_is_datetime
+    cell = datetime.new('30000.323212', nil, [], nil, nil, base_date, nil)
+    assert_equal :datetime, cell.type
+  end
+
+  def test_standard_formatted_value
+    [
+      ['mm-dd-yy', '01-25-15'],
+      ['d-mmm-yy', '25-JAN-15'],
+      ['d-mmm ', '25-JAN'],
+      ['mmm-yy', 'JAN-15'],
+      ['m/d/yy h:mm', '1/25/15 8:15']
+    ].each do |format, formatted_value|
+      cell = datetime.new '42029.34375', nil, [format], nil, nil, base_date, nil
+      assert_equal formatted_value, cell.formatted_value
+    end
+  end
+
+  def test_custom_formatted_value
+    [
+      ['yyyy/mm/dd hh:mm:ss', '2015/01/25 08:15:00'],
+      ['h:mm:ss000 mm/yy', '8:15:00000 01/15'],
+      ['mmm yyy', '2015-01-25 08:15:00']
+    ].each do |format, formatted_value|
+      cell = datetime.new '42029.34375', nil, [format], nil, nil, base_date, nil
+      assert_equal formatted_value, cell.formatted_value
+    end
+  end
+
+  def datetime
+    Roo::Excelx::Cell::DateTime
+  end
+
+  def base_date
+    Date.new(1899, 12, 30)
+  end
+end

data/test/excelx/cell/test_empty.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class TestRooExcelxCellEmpty < Minitest::Test
+  def empty
+    Roo::Excelx::Cell::Empty
+  end
+end

data/test/excelx/cell/test_number.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+class TestRooExcelxCellNumber < Minitest::Test
+  def number
+    Roo::Excelx::Cell::Number
+  end
+
+  def test_float
+    cell = Roo::Excelx::Cell::Number.new '42.1', nil, ['General'], nil, nil, nil
+    assert_kind_of(Float, cell.value)
+  end
+
+  def test_integer
+    cell = Roo::Excelx::Cell::Number.new '42', nil, ['0'], nil, nil, nil
+    assert_kind_of(Integer, cell.value)
+  end
+
+  def test_scientific_notation
+    cell = Roo::Excelx::Cell::Number.new '1.2E-3', nil, ['0'], nil, nil, nil
+    assert_kind_of(Float, cell.value)
+  end
+
+  def test_simple_scientific_notation
+    cell = Roo::Excelx::Cell::Number.new '1E-3', nil, ['0'], nil, nil, nil
+    assert_kind_of(Float, cell.value)
+  end
+
+  def test_percent
+    cell = Roo::Excelx::Cell::Number.new '42.1', nil, ['0.00%'], nil, nil, nil
+    assert_kind_of(Float, cell.value)
+  end
+
+  def test_formats_with_negative_numbers
+    [
+      ['#,##0 ;(#,##0)', '(1,042)'],
+      ['#,##0 ;[Red](#,##0)', '[Red](1,042)'],
+      ['#,##0.00;(#,##0.00)', '(1,042.00)'],
+      ['#,##0.00;[Red](#,##0.00)', '[Red](1,042.00)']
+    ].each do |style_format, result|
+      cell = Roo::Excelx::Cell::Number.new '-1042', nil, [style_format], nil, nil, nil
+      assert_equal result, cell.formatted_value, "Style=#{style_format}"
+    end
+  end
+
+  def test_numbers_with_cell_errors
+    Roo::Excelx::ERROR_VALUES.each do |error|
+      cell = Roo::Excelx::Cell::Number.new error, nil, ['General'], nil, nil, nil
+      assert_equal error, cell.value
+      assert_equal error, cell.formatted_value
+    end
+  end
+
+  def test_formats
+    [
+      ['General', '1042'],
+      ['0', '1042'],
+      ['0.00', '1042.00'],
+      ['#,##0', '1,042'],
+      ['#,##0.00', '1,042.00'],
+      ['0%', '104200%'],
+      ['0.00%', '104200.00%'],
+      ['0.00E+00', '1.04E+03'],
+      ['#,##0 ;(#,##0)', '1,042'],
+      ['#,##0 ;[Red](#,##0)', '1,042'],
+      ['#,##0.00;(#,##0.00)', '1,042.00'],
+      ['#,##0.00;[Red](#,##0.00)', '1,042.00'],
+      ['##0.0E+0', '1.0E+03'],
+      ['@', '1042']
+    ].each do |style_format, result|
+      cell = Roo::Excelx::Cell::Number.new '1042', nil, [style_format], nil, nil, nil
+      assert_equal result, cell.formatted_value, "Style=#{style_format}"
+    end
+  end
+end

data/test/excelx/cell/test_string.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class TestRooExcelxCellString < Minitest::Test
+  def string
+    Roo::Excelx::Cell::String
+  end
+
+
+  def test_formatted_value
+    cell = string.new '1', nil, nil, nil, nil
+    assert_equal '1', cell.formatted_value
+  end
+
+  def test_to_s
+    cell = string.new '0', nil, nil, nil, nil
+    assert_equal '0', cell.to_s
+  end
+
+  def test_cell_value
+    cell = string.new '1', nil, nil, nil, nil
+    assert_equal '1', cell.cell_value
+  end
+
+  def test_value
+    cell = string.new '0', nil, nil, nil, nil
+    assert_equal '0', cell.value
+  end
+end

data/test/excelx/cell/test_time.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class TestRooExcelxCellTime < Minitest::Test
+  def roo_time
+    Roo::Excelx::Cell::Time
+  end
+
+  def base_date
+    Date.new(1899, 12, 30)
+  end
+
+  def test_formatted_value
+    value = '0.0751' # 6488.64 seconds, or 1:48:08.64
+    [
+      ['h:mm', '1:48'],
+      ['h:mm:ss', '1:48:09'],
+      ['mm:ss', '48:09'],
+      ['[h]:mm:ss', '[1]:48:09'],
+      ['mmss.0', '4809.0'] # Cell::Time always get rounded to the nearest second.
+    ].each do |style_format, result|
+      cell = roo_time.new(value, nil, [:numeric_or_formula, style_format], 6, nil, base_date, nil)
+      assert_equal result, cell.formatted_value, "Style=#{style_format} is not properly formatted"
+    end
+  end
+
+  def test_value
+    cell = roo_time.new('0.0751', nil, [:numeric_or_formula, 'h:mm'], 6, nil, base_date, nil)
+    assert_kind_of Integer, cell.value
+  end
+end

data/test/formatters/test_csv.rb

@@ -0,0 +1,119 @@
+require "test_helper"
+
+class TestRooFormatterCSV < Minitest::Test
+  def test_date_time_to_csv
+    with_each_spreadsheet(name: "time-test") do |workbook|
+      Dir.mktmpdir do |tempdir|
+        csv_output = File.join(tempdir, "time_test.csv")
+        assert workbook.to_csv(csv_output)
+        assert File.exist?(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 |workbook|
+      Dir.mktmpdir do |tempdir|
+        csv_output = File.join(tempdir,"boolean.csv")
+        assert workbook.to_csv(csv_output)
+        assert File.exist?(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 |workbook|
+      Dir.mktmpdir do |tempdir|
+        csv_output = File.join(tempdir, "link.csv")
+        assert workbook.to_csv(csv_output)
+        assert File.exist?(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
+
+  # "/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
+    skip_long_test
+
+    original_csv_path = File.join(TESTDIR, "Bibelbund.csv")
+    with_each_spreadsheet(name: "Bibelbund", format: [:openoffice, :excelx]) do |workbook|
+      Dir.mktmpdir do |tempdir|
+        new_csv_path = File.join(tempdir, "Bibelbund.csv")
+        assert_equal "Tagebuch des Sekret\303\244rs.    Letzte Tagung 15./16.11.75 Schweiz", workbook.cell(45, "A")
+        assert_equal "Tagebuch des Sekret\303\244rs.  Nachrichten aus Chile", workbook.cell(46, "A")
+        assert_equal "Tagebuch aus Chile  Juli 1977", workbook.cell(55, "A")
+        assert workbook.to_csv(new_csv_path)
+        assert File.exist?(new_csv_path)
+        assert FileUtils.identical?(original_csv_path, new_csv_path), "error in class #{workbook.class}"
+      end
+    end
+  end
+
+  def test_bug_empty_sheet
+    with_each_spreadsheet(name: "formula", format: [:openoffice, :excelx]) do |workbook|
+      workbook.default_sheet = "Sheet3" # is an empty sheet
+      Dir.mktmpdir do |tempdir|
+        workbook.to_csv(File.join(tempdir, "emptysheet.csv"))
+        assert_equal "", `cat #{File.join(tempdir, "emptysheet.csv")}`
+      end
+    end
+  end
+
+  def test_bug_quotes_excelx
+    skip_long_test
+    # TODO: run this test with a much smaller document
+    with_each_spreadsheet(name: "Bibelbund", format: [:openoffice, :excelx]) do |workbook|
+      workbook.default_sheet = workbook.sheets.first
+      assert_equal(
+        'Einflüsse der neuen Theologie in "de gereformeerde Kerken van Nederland"',
+        workbook.cell("A", 76)
+      )
+      workbook.to_csv("csv#{$$}")
+      assert_equal(
+        'Einflüsse der neuen Theologie in "de gereformeerde Kerken van Nederland"',
+        workbook.cell("A", 78)
+      )
+      File.delete_if_exist("csv#{$$}")
+    end
+  end
+
+  def test_bug_datetime_to_csv
+    with_each_spreadsheet(name: "datetime") do |workbook|
+      Dir.mktmpdir do |tempdir|
+        datetime_csv_file = File.join(tempdir, "datetime.csv")
+
+        assert workbook.to_csv(datetime_csv_file)
+        assert File.exist?(datetime_csv_file)
+        assert_equal "", file_diff("#{TESTDIR}/so_datetime.csv", datetime_csv_file)
+      end
+    end
+  end
+
+  def test_true_class
+    assert_equal "true", cell_to_csv(1, 1)
+  end
+
+  def test_false_class
+    assert_equal "false", cell_to_csv(2, 1)
+  end
+
+  def test_date_class
+    assert_equal "2017-01-01", cell_to_csv(3, 1)
+  end
+
+  def cell_to_csv(row, col)
+    filename = File.join(TESTDIR, "formula_cell_types.xlsx")
+    Roo::Spreadsheet.open(filename).send("cell_to_csv", row, col, "Sheet1")
+  end
+end

data/test/formatters/test_matrix.rb

@@ -0,0 +1,76 @@
+require "test_helper"
+require "matrix"
+
+class TestRooFormatterMatrix < Minitest::Test
+  def test_matrix
+    expected_result = Matrix[
+      [1.0, 2.0, 3.0],
+      [4.0, 5.0, 6.0],
+      [7.0, 8.0, 9.0]
+    ]
+    with_each_spreadsheet(name: "matrix", format: :openoffice) do |workbook|
+      workbook.default_sheet = workbook.sheets.first
+      assert_equal expected_result, workbook.to_matrix
+    end
+  end
+
+  def test_matrix_selected_range
+    expected_result = Matrix[
+      [1.0, 2.0, 3.0],
+      [4.0, 5.0, 6.0],
+      [7.0, 8.0, 9.0]
+    ]
+    with_each_spreadsheet(name: "matrix", format: :openoffice) do |workbook|
+      workbook.default_sheet = "Sheet2"
+      assert_equal expected_result, workbook.to_matrix(3, 4, 5, 6)
+    end
+  end
+
+  def test_matrix_all_nil
+    expected_result = Matrix[
+      [nil, nil, nil],
+      [nil, nil, nil],
+      [nil, nil, nil]
+    ]
+    with_each_spreadsheet(name: "matrix", format: :openoffice) do |workbook|
+      workbook.default_sheet = "Sheet2"
+      assert_equal expected_result, workbook.to_matrix(10, 10, 12, 12)
+    end
+  end
+
+  def test_matrix_values_and_nil
+    expected_result = Matrix[
+      [1.0, nil, 3.0],
+      [4.0, 5.0, 6.0],
+      [7.0, 8.0, nil]
+    ]
+    with_each_spreadsheet(name: "matrix", format: :openoffice) do |workbook|
+      workbook.default_sheet = "Sheet3"
+      assert_equal expected_result, workbook.to_matrix(1, 1, 3, 3)
+    end
+  end
+
+  def test_matrix_specifying_sheet
+    expected_result = Matrix[
+      [1.0, nil, 3.0],
+      [4.0, 5.0, 6.0],
+      [7.0, 8.0, nil]
+    ]
+    with_each_spreadsheet(name: "matrix", format: :openoffice) do |workbook|
+      workbook.default_sheet = workbook.sheets.first
+      assert_equal expected_result, workbook.to_matrix(nil, nil, nil, nil, "Sheet3")
+    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
+    options = { name: "emptysheets", format: [:openoffice, :excelx] }
+    with_each_spreadsheet(options) do |workbook|
+      workbook.default_sheet = workbook.sheets.first
+      workbook.to_matrix
+      assert_equal(Matrix.empty(0, 0), workbook.to_matrix)
+    end
+  end
+end

data/test/formatters/test_xml.rb

@@ -0,0 +1,78 @@
+require "test_helper"
+
+class TestRooFormatterXML < Minitest::Test
+  def test_to_xml
+    expected_sheet_count = 5
+    options = { name: "numbers1", encoding: "utf8" }
+    with_each_spreadsheet(options) do |workbook|
+      skip if defined? JRUBY_VERSION
+      workbook.to_xml
+      sheetname = workbook.sheets.first
+      doc = Nokogiri::XML(workbook.to_xml)
+
+      assert_equal expected_sheet_count, doc.xpath("//spreadsheet/sheet").count
+
+      doc.xpath("//spreadsheet/sheet").each do |xml_sheet|
+        all_cells = init_all_cells(workbook, sheetname)
+        cells = xml_sheet.children.reject(&:text?)
+
+        assert_equal sheetname, xml_sheet.attribute("name").value
+        assert_equal all_cells.size, cells.size
+
+        cells.each_with_index do |cell, i|
+          expected = [
+            all_cells[i][:row],
+            all_cells[i][:column],
+            all_cells[i][:content],
+            all_cells[i][:type],
+          ]
+          result = [
+            cell.attribute("row").value,
+            cell.attribute("column").value,
+            cell.text,
+            cell.attribute("type").value,
+          ]
+
+          assert_equal expected, result
+        end # end of sheet
+        sheetname = workbook.sheets[workbook.sheets.index(sheetname) + 1]
+      end
+    end
+  end
+
+  def test_bug_to_xml_with_empty_sheets
+    with_each_spreadsheet(name: "emptysheets", format: [:openoffice, :excelx]) do |workbook|
+      workbook.sheets.each do |sheet|
+        assert_nil workbook.first_row, "first_row not nil in sheet #{sheet}"
+        assert_nil workbook.last_row, "last_row not nil in sheet #{sheet}"
+        assert_nil workbook.first_column, "first_column not nil in sheet #{sheet}"
+        assert_nil workbook.last_column, "last_column not nil in sheet #{sheet}"
+        assert_nil workbook.first_row(sheet), "first_row not nil in sheet #{sheet}"
+        assert_nil workbook.last_row(sheet), "last_row not nil in sheet #{sheet}"
+        assert_nil workbook.first_column(sheet), "first_column not nil in sheet #{sheet}"
+        assert_nil workbook.last_column(sheet), "last_column not nil in sheet #{sheet}"
+      end
+      workbook.to_xml
+    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(workbook, sheet)
+    all = []
+    workbook.first_row(sheet).upto(workbook.last_row(sheet)) do |row|
+      workbook.first_column(sheet).upto(workbook.last_column(sheet)) do |col|
+        next if workbook.empty?(row, col, sheet)
+
+        all << {
+          row: row.to_s,
+          column: col.to_s,
+          content: workbook.cell(row, col, sheet).to_s,
+          type: workbook.celltype(row, col, sheet).to_s,
+        }
+      end
+    end
+    all
+  end
+end

data/test/formatters/test_yaml.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+
+class TestRooFormatterYAML < Minitest::Test
+  def test_date_time_yaml
+    name = "time-test"
+    expected = File.open(TESTDIR + "/expected_results/#{name}.yml").read
+    with_each_spreadsheet(name: name) do |workbook|
+      assert_equal expected, workbook.to_yaml
+    end
+  end
+
+  def test_bug_to_yaml_empty_sheet
+    formats = [:openoffice, :excelx]
+    with_each_spreadsheet(name: "emptysheets", format: formats) do |workbook|
+      workbook.default_sheet = workbook.sheets.first
+      workbook.to_yaml
+      assert_equal "", workbook.to_yaml
+    end
+  end
+end

data/test/helpers/test_accessing_files.rb

@@ -0,0 +1,60 @@
+# Tests for "Accessing Files" which includes opening and closing files.
+module TestAccesingFiles
+  def test_close
+    with_each_spreadsheet(name: "numbers1") do |oo|
+      next unless (tempdir = oo.instance_variable_get("@tmpdir"))
+      oo.close
+      refute File.exist?(tempdir), "Expected #{tempdir} to be cleaned up"
+    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
+    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
+    end
+
+    Process.wait(pid)
+    write.close
+    tempdirs = read.read.split("\n")
+    read.close
+
+    refute tempdirs.empty?
+    tempdirs.each do |tempdir|
+      refute File.exist?(tempdir), "Expected #{tempdir} to be cleaned up"
+    end
+  end
+
+  def test_cleanup_on_error
+    # NOTE: This test was occasionally failing because when it started running
+    #       other tests would have already added folders to the temp directory,
+    #       polluting the directory. You'd end up in a situation where there
+    #       would be less folders AFTER this ran than originally started.
+    #
+    #       Instead, just use a custom temp directory to test the functionality.
+    ENV["ROO_TMP"] = Dir.tmpdir + "/test_cleanup_on_error"
+    Dir.mkdir(ENV["ROO_TMP"]) unless File.exist?(ENV["ROO_TMP"])
+    expected_dir_contents = Dir.open(ENV["ROO_TMP"]).to_a
+    with_each_spreadsheet(name: "non_existent_file", ignore_errors: true) {}
+
+    assert_equal expected_dir_contents, Dir.open(ENV["ROO_TMP"]).to_a
+    Dir.rmdir ENV["ROO_TMP"] if File.exist?(ENV["ROO_TMP"])
+    ENV.delete "ROO_TMP"
+  end
+
+  def test_name_with_leading_slash
+    xlsx = Roo::Excelx.new(File.join(TESTDIR, "/name_with_leading_slash.xlsx"))
+    assert_equal 1, xlsx.sheets.count
+  end
+end