#damit keine falschen Vermutungen aufkommen: Ich habe religoes rein gar nichts
# mit diesem Bibelbund zu tun, aber die hatten eine ziemlich grosse
# Spreadsheet-Datei 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
#
require File.dirname(__FILE__) + '/test_helper.rb'
#require 'soap/rpc/driver'
require 'fileutils'
require 'timeout'

# helper method
def local_only
  if ENV["roo_local"] == "thomas-p"
    yield
  end
end

DISPLAY_LOG = false
DB_LOG = false

if DB_LOG
  # gem 'activerecord', '< 2.0.0'
  # require 'activerecord'
  # require_gem 'activerecord', '< 2.0.0'
  #gem 'activerecord', '< 2.0.0'
  require 'activerecord'
end

include FileUtils

if DB_LOG
  def activerecord_connect
    ActiveRecord::Base.establish_connection(:adapter => "mysql",
      :database => "test_runs",
      :host => "localhost",
      :username => "root",
      :socket => "/var/run/mysqld/mysqld.sock")
  end

  class Testrun < ActiveRecord::Base
  end
end

class Test::Unit::TestCase
  def key_of(spreadsheetname)
    begin
      return {
        'numbers1' => "o10837434939102457526.4784396906364855777",
        'borders' => "o10837434939102457526.664868920231926255",
        'simple_spreadsheet' => "ptu6bbahNZpYe-L1vEBmgGA",
        'testnichtvorhandenBibelbund.ods' => "invalidkeyforanyspreadsheet", # !!! intentionally false key
        "only_one_sheet" => "o10837434939102457526.762705759906130135",
        "write.me" => 'ptu6bbahNZpY0N0RrxQbWdw&hl',
        'formula' => 'o10837434939102457526.3022866619437760118',
        'time-test' => 'ptu6bbahNZpYBMhk01UfXSg',
      }[spreadsheetname]
    rescue
      raise "unknown spreadsheetname: #{spreadsheetname}"
    end
  end

  if DB_LOG
    if ! (defined?(@connected) and @connected)
      activerecord_connect
    else
      @connected = true
    end
  end
  alias unlogged_run run
  def run(result, &block)
    t1 = Time.now
    #RAILS_DEFAULT_LOGGER.debug "RUNNING #{self.class} #{@method_name} \t#{Time.now.to_s}"
    if DISPLAY_LOG
      print "RUNNING #{self.class} #{@method_name} \t#{Time.now.to_s}"
    end
    unlogged_run result, &block
    t2 = Time.now
    if DISPLAY_LOG
      puts "\t#{t2-t1} seconds"
    end
    #      record = {'class' => self.class.to_s,
    #              'test'  => @method_name,
    #              'start' => t1,
    #              'duration' => t2-t1}
    #      open('test_runs.yml','a') { |f| YAML.dump(record, f) }
    #      #--
    if DB_LOG
      #      p self.class.to_s
      #p @method_name
      #p t1
      #p t2-t1
      domain = Testrun.create(
        :class_name => self.class.to_s,
        :test_name => @method_name,
        :start => t1,
        :duration => t2-t1
      )
    end
  end
end

class File

  def File.delete_if_exist(filename)
    if File.exist?(filename)
      File.delete(filename)
    end
  end

end

class TestRoo < Test::Unit::TestCase

  OPENOFFICE = true  	# do Openoffice-Spreadsheet Tests?
  EXCEL      = true  	# do Excel Tests?
  GOOGLE     = false 	# do Google-Spreadsheet Tests?
  GNUMERIC_ODS = false # do gnumeric with ods files Tests?
  EXCELX      = true  	# do Excel-X Tests? (.xlsx-files)

  OPENOFFICEWRITE = false # experimental: write access with OO-Documents
  ONLINE = false
  LONG_RUN = false
  GLOBAL_TIMEOUT = 2*12*60 # seconds


  # helper method
  def after(d)
    yield if DateTime.now > d
  end

  # helper method
  def before(d)
    yield if DateTime.now <= d
  end

  def setup
    if DISPLAY_LOG
      puts "GLOBAL_TIMEOUT = #{GLOBAL_TIMEOUT}"
    end
  end

  def test_date
    assert Google.date?("21/11/1962")
    assert_equal Date.new(1962,11,21), Google.to_date("21/11/1962")

    assert !Google.date?("21")
    assert_nil Google.to_date("21")

    assert !Google.date?("21/11")
    assert_nil Google.to_date("21/11")

    assert !Google.date?("Mittwoch/21/1961")
    assert_nil Google.to_date("Mittwoch/21/1961")
  end

  def test_classes
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      assert_kind_of Openoffice, oo
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      assert_kind_of Excel, oo
    end
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      assert_kind_of Google, oo
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      assert_kind_of Excelx, oo
    end
  end

  def test_letters
    assert_equal 1, GenericSpreadsheet.letter_to_number('A')
    assert_equal 1, GenericSpreadsheet.letter_to_number('a')
    assert_equal 2, GenericSpreadsheet.letter_to_number('B')
    assert_equal 26, GenericSpreadsheet.letter_to_number('Z')
    assert_equal 27, GenericSpreadsheet.letter_to_number('AA')
    assert_equal 27, GenericSpreadsheet.letter_to_number('aA')
    assert_equal 27, GenericSpreadsheet.letter_to_number('Aa')
    assert_equal 27, GenericSpreadsheet.letter_to_number('aa')
  end

  def DONT_test_simple_google
    if GOOGLE
      go = Google.new("egal")
      assert_equal "42", go.cell(1,1)
    end
  end

  def test_sheets_openoffice
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      assert_equal ["Tabelle1","Name of Sheet 2","Sheet3","Sheet4","Sheet5"], oo.sheets
      assert_raise(RangeError) {
        oo.default_sheet = "no_sheet"
      }
      assert_raise(TypeError) {
        oo.default_sheet = [1,2,3]
      }

      oo.sheets.each { |sh|
        oo.default_sheet = sh
        assert_equal sh, oo.default_sheet
      }
    end
  end

  def test_sheets_gnumeric_ods
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      assert_equal ["Tabelle1","Name of Sheet 2","Sheet3","Sheet4","Sheet5"], oo.sheets
      assert_raise(RangeError) {
        oo.default_sheet = "no_sheet"
      }
      assert_raise(TypeError) {
        oo.default_sheet = [1,2,3]
      }

      oo.sheets.each { |sh|
        oo.default_sheet = sh
        assert_equal sh, oo.default_sheet
      }
    end
  end

  def test_sheets_excel
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      assert_equal ["Tabelle1","Name of Sheet 2","Sheet3","Sheet4","Sheet5"], oo.sheets
      assert_raise(RangeError) {
        oo.default_sheet = "no_sheet"
      }
      assert_raise(TypeError) {
        oo.default_sheet = [1,2,3]
      }
      oo.sheets.each { |sh|
        oo.default_sheet = sh
        assert_equal sh, oo.default_sheet
      }
    end
  end

  def test_sheets_excelx
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      assert_equal ["Tabelle1","Name of Sheet 2","Sheet3","Sheet4","Sheet5"], oo.sheets
      assert_raise(RangeError) {
        oo.default_sheet = "no_sheet"
      }
      assert_raise(TypeError) {
        oo.default_sheet = [1,2,3]
      }
      oo.sheets.each { |sh|
        oo.default_sheet = sh
        assert_equal sh, oo.default_sheet
      }
    end
  end
  
  def test_sheets_google
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      assert_equal ["Tabelle1","Name of Sheet 2","Sheet3","Sheet4","Sheet5"], oo.sheets
      assert_raise(RangeError) {
        oo.default_sheet = "no_sheet"
      }
      assert_raise(TypeError) {
        oo.default_sheet = [1,2,3]
      }
      oo.sheets.each { |sh|
        oo.default_sheet = sh
        assert_equal sh, oo.default_sheet
      }
    end
  end

  def test_cell_openoffice
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.cell(1,1)
      assert_equal 2, oo.cell(1,2)
      assert_equal 3, oo.cell(1,3)
      assert_equal 4, oo.cell(1,4)
      assert_equal 5, oo.cell(2,1)
      assert_equal 6, oo.cell(2,2)
      assert_equal 7, oo.cell(2,3)
      assert_equal 8, oo.cell(2,4)
      assert_equal 9, oo.cell(2,5)
      assert_equal "test", oo.cell(2,6)
      # assert_equal "string", oo.celltype(2,6)
      assert_equal :string, oo.celltype(2,6)
      assert_equal 11, oo.cell(2,7)
      # assert_equal "float", oo.celltype(2,7)
      assert_equal :float, oo.celltype(2,7)

      assert_equal 10, oo.cell(4,1)
      assert_equal 11, oo.cell(4,2)
      assert_equal 12, oo.cell(4,3)
      assert_equal 13, oo.cell(4,4)
      assert_equal 14, oo.cell(4,5)

      assert_equal 10, oo.cell(4,'A')
      assert_equal 11, oo.cell(4,'B')
      assert_equal 12, oo.cell(4,'C')
      assert_equal 13, oo.cell(4,'D')
      assert_equal 14, oo.cell(4,'E')

      # assert_equal "date", oo.celltype(5,1)
      assert_equal :date, oo.celltype(5,1)
      assert_equal Date.new(1961,11,21), oo.cell(5,1)
      assert_equal "1961-11-21", oo.cell(5,1).to_s
    end
  end

  def test_cell_gnumeric_ods
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.cell(1,1)
      assert_equal 2, oo.cell(1,2)
      assert_equal 3, oo.cell(1,3)
      assert_equal 4, oo.cell(1,4)
      assert_equal 5, oo.cell(2,1)
      assert_equal 6, oo.cell(2,2)
      assert_equal 7, oo.cell(2,3)
      assert_equal 8, oo.cell(2,4)
      assert_equal 9, oo.cell(2,5)
      assert_equal "test", oo.cell(2,6)
      # assert_equal "string", oo.celltype(2,6)
      assert_equal :string, oo.celltype(2,6)
      assert_equal 11, oo.cell(2,7)
      # assert_equal "float", oo.celltype(2,7)
      assert_equal :float, oo.celltype(2,7)

      assert_equal 10, oo.cell(4,1)
      assert_equal 11, oo.cell(4,2)
      assert_equal 12, oo.cell(4,3)
      assert_equal 13, oo.cell(4,4)
      assert_equal 14, oo.cell(4,5)

      assert_equal 10, oo.cell(4,'A')
      assert_equal 11, oo.cell(4,'B')
      assert_equal 12, oo.cell(4,'C')
      assert_equal 13, oo.cell(4,'D')
      assert_equal 14, oo.cell(4,'E')

      # assert_equal "date", oo.celltype(5,1)
      assert_equal :date, oo.celltype(5,1)
      assert_equal Date.new(1961,11,21), oo.cell(5,1)
      assert_equal "1961-11-21", oo.cell(5,1).to_s
    end
  end

  def test_cell_excel
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.cell(1,1)
      assert_equal 2, oo.cell(1,2)
      assert_equal 3, oo.cell(1,3)
      assert_equal 4, oo.cell(1,4)
      assert_equal 5, oo.cell(2,1)
      assert_equal 6, oo.cell(2,2)
      assert_equal 7, oo.cell(2,3)
      assert_equal 8, oo.cell(2,4)
      assert_equal 9, oo.cell(2,5)
      assert_equal "test", oo.cell(2,6)
      # assert_equal "string", oo.celltype(2,6)
      assert_equal :string, oo.celltype(2,6)
      assert_equal 11, oo.cell(2,7)
      # assert_equal "float", oo.celltype(2,7)
      assert_equal :float, oo.celltype(2,7)

      assert_equal 10, oo.cell(4,1)
      assert_equal 11, oo.cell(4,2)
      assert_equal 12, oo.cell(4,3)
      assert_equal 13, oo.cell(4,4)
      assert_equal 14, oo.cell(4,5)

      assert_equal 10, oo.cell(4,'A')
      assert_equal 11, oo.cell(4,'B')
      assert_equal 12, oo.cell(4,'C')
      assert_equal 13, oo.cell(4,'D')
      assert_equal 14, oo.cell(4,'E')

      # assert_equal "date", oo.celltype(5,1)
      assert_equal :date, oo.celltype(5,1)
      assert_equal Date.new(1961,11,21), oo.cell(5,1)
      assert_equal "1961-11-21", oo.cell(5,1).to_s
    end
  end

  def test_cell_excelx
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      
      assert_kind_of Float, oo.cell(1,1)
      assert_equal 1, oo.cell(1,1)
      assert_equal 2, oo.cell(1,2)
      assert_equal 3, oo.cell(1,3)
      assert_equal 4, oo.cell(1,4)
      assert_equal 5, oo.cell(2,1)
      assert_equal 6, oo.cell(2,2)
      assert_equal 7, oo.cell(2,3)
      assert_equal 8, oo.cell(2,4)
      assert_equal 9, oo.cell(2,5)
      assert_equal "test", oo.cell(2,6)
      # assert_equal "string", oo.celltype(2,6)
      assert_equal :string, oo.celltype(2,6)
      assert_equal 11, oo.cell(2,7)
      # assert_equal "float", oo.celltype(2,7)
      assert_equal :float, oo.celltype(2,7)

      assert_equal 10, oo.cell(4,1)
      assert_equal 11, oo.cell(4,2)
      assert_equal 12, oo.cell(4,3)
      assert_equal 13, oo.cell(4,4)
      assert_equal 14, oo.cell(4,5)

      assert_equal 10, oo.cell(4,'A')
      assert_equal 11, oo.cell(4,'B')
      assert_equal 12, oo.cell(4,'C')
      assert_equal 13, oo.cell(4,'D')
      assert_equal 14, oo.cell(4,'E')

      # assert_equal "date", oo.celltype(5,1)
      assert_equal :date, oo.celltype(5,1)
      assert_equal Date.new(1961,11,21), oo.cell(5,1)
      assert_equal "1961-11-21", oo.cell(5,1).to_s
    end
  end
  
  def test_cell_google
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.cell(1,1)
      assert_equal 2, oo.cell(1,2)
      assert_equal 3, oo.cell(1,3)
      assert_equal 4, oo.cell(1,4)
      assert_equal 5, oo.cell(2,1)
      assert_equal 6, oo.cell(2,2)
      assert_equal 7, oo.cell(2,3)
      assert_equal 8, oo.cell(2,4)
      assert_equal 9, oo.cell(2,5)
      assert_equal "test", oo.cell(2,6)
      # assert_equal "string", oo.celltype(2,6)
      assert_equal :string, oo.celltype(2,6)
      assert_equal 11, oo.cell(2,7)
      # assert_equal "float", oo.celltype(2,7)
      assert_equal :float, oo.celltype(2,7), "Inhalt: --#{oo.cell(2,7)}--"

      assert_equal 10, oo.cell(4,1)
      assert_equal 11, oo.cell(4,2)
      assert_equal 12, oo.cell(4,3)
      assert_equal 13, oo.cell(4,4)
      assert_equal 14, oo.cell(4,5)

      assert_equal 10, oo.cell(4,'A')
      assert_equal 11, oo.cell(4,'B')
      assert_equal 12, oo.cell(4,'C')
      assert_equal 13, oo.cell(4,'D')
      assert_equal 14, oo.cell(4,'E')

      # assert_equal "date", oo.celltype(5,1)
      assert_equal :date, oo.celltype(5,1)
      assert_equal Date.new(1961,11,21), oo.cell(5,1)
      assert_equal "1961-11-21", oo.cell(5,1).to_s
    end # GOOGLE
  end

  def test_celltype
    ###
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal :string, oo.celltype(2,6)
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal :string, oo.celltype(2,6)
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = oo.sheets.first
      assert_equal :string, oo.celltype(2,6)
    end
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      oo.default_sheet = oo.sheets.first
      assert_equal :string, oo.celltype(2,6)
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal :string, oo.celltype(2,6)
    end
  end

  def test_cell_address
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal "tata", oo.cell(6,1)
      assert_equal "tata", oo.cell(6,'A')
      assert_equal "tata", oo.cell('A',6)
      assert_equal "tata", oo.cell(6,'a')
      assert_equal "tata", oo.cell('a',6)

      assert_raise(ArgumentError) {
        assert_equal "tata", oo.cell('a','f')
      }
      assert_raise(ArgumentError) {
        assert_equal "tata", oo.cell('f','a')
      }
      assert_equal "thisisc8", oo.cell(8,3)
      assert_equal "thisisc8", oo.cell(8,'C')
      assert_equal "thisisc8", oo.cell('C',8)
      assert_equal "thisisc8", oo.cell(8,'c')
      assert_equal "thisisc8", oo.cell('c',8)

      assert_equal "thisisd9", oo.cell('d',9)
      assert_equal "thisisa11", oo.cell('a',11)
    end

    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal "tata", oo.cell(6,1)
      assert_equal "tata", oo.cell(6,'A')
      assert_equal "tata", oo.cell('A',6)
      assert_equal "tata", oo.cell(6,'a')
      assert_equal "tata", oo.cell('a',6)

      assert_raise(ArgumentError) {
        assert_equal "tata", oo.cell('a','f')
      }
      assert_raise(ArgumentError) {
        assert_equal "tata", oo.cell('f','a')
      }
      assert_equal "thisisc8", oo.cell(8,3)
      assert_equal "thisisc8", oo.cell(8,'C')
      assert_equal "thisisc8", oo.cell('C',8)
      assert_equal "thisisc8", oo.cell(8,'c')
      assert_equal "thisisc8", oo.cell('c',8)

      assert_equal "thisisd9", oo.cell('d',9)
      assert_equal "thisisa11", oo.cell('a',11)
    end

    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = oo.sheets.first
      assert_equal "tata", oo.cell(6,1)
      assert_equal "tata", oo.cell(6,'A')
      assert_equal "tata", oo.cell('A',6)
      assert_equal "tata", oo.cell(6,'a')
      assert_equal "tata", oo.cell('a',6)

      assert_raise(ArgumentError) {
        assert_equal "tata", oo.cell('a','f')
      }
      assert_raise(ArgumentError) {
        assert_equal "tata", oo.cell('f','a')
      }

      assert_equal "thisisc8", oo.cell(8,3)
      assert_equal "thisisc8", oo.cell(8,'C')
      assert_equal "thisisc8", oo.cell('C',8)
      assert_equal "thisisc8", oo.cell(8,'c')
      assert_equal "thisisc8", oo.cell('c',8)

      assert_equal "thisisd9", oo.cell('d',9)
      assert_equal "thisisa11", oo.cell('a',11)
      #assert_equal "lulua", oo.cell('b',10)
    end

    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal "tata", oo.cell(6,1)
      assert_equal "tata", oo.cell(6,'A')
      assert_equal "tata", oo.cell('A',6)
      assert_equal "tata", oo.cell(6,'a')
      assert_equal "tata", oo.cell('a',6)

      assert_raise(ArgumentError) {
        assert_equal "tata", oo.cell('a','f')
      }
      assert_raise(ArgumentError) {
        assert_equal "tata", oo.cell('f','a')
      }

      assert_equal "thisisc8", oo.cell(8,3)
      assert_equal "thisisc8", oo.cell(8,'C')
      assert_equal "thisisc8", oo.cell('C',8)
      assert_equal "thisisc8", oo.cell(8,'c')
      assert_equal "thisisc8", oo.cell('c',8)

      assert_equal "thisisd9", oo.cell('d',9)
      assert_equal "thisisa11", oo.cell('a',11)
      #assert_equal "lulua", oo.cell('b',10)
    end

    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      oo.default_sheet = oo.sheets.first
      assert_equal "tata", oo.cell(6,1)
      assert_equal "tata", oo.cell(6,'A')
      assert_equal "tata", oo.cell('A',6)
      assert_equal "tata", oo.cell(6,'a')
      assert_equal "tata", oo.cell('a',6)

      assert_raise(ArgumentError) {
        assert_equal "tata", oo.cell('a','f')
      }
      assert_raise(ArgumentError) {
        assert_equal "tata", oo.cell('f','a')
      }
      assert_equal "thisisc8", oo.cell(8,3)
      assert_equal "thisisc8", oo.cell(8,'C')
      assert_equal "thisisc8", oo.cell('C',8)
      assert_equal "thisisc8", oo.cell(8,'c')
      assert_equal "thisisc8", oo.cell('c',8)

      assert_equal "thisisd9", oo.cell('d',9)
      assert_equal "thisisa11", oo.cell('a',11)
    end
  end

  # Version of the (XML) office document
  # please note that "1.0" is returned even if it was created with OpenOffice V. 2.0
  def test_officeversion
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      assert_equal "1.0", oo.officeversion
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      assert_equal "1.0", oo.officeversion
    end
    if EXCEL
      # excel does not have a officeversion
    end
    if EXCELX
      # excelx does not have a officeversion
      #TODO: gibt es hier eine Versionsnummer
    end
    if GOOGLE
      # google does not have a officeversion
    end
  end
  
  #TODO: inkonsequente Lieferung Fixnum/Float
  def test_rows
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 41, oo.cell('a',12)
      assert_equal 42, oo.cell('b',12)
      assert_equal 43, oo.cell('c',12)
      assert_equal 44, oo.cell('d',12)
      assert_equal 45, oo.cell('e',12)
      assert_equal [41.0,42.0,43.0,44.0,45.0], oo.row(12)
      assert_equal "einundvierzig", oo.cell('a',16)
      assert_equal "zweiundvierzig", oo.cell('b',16)
      assert_equal "dreiundvierzig", oo.cell('c',16)
      assert_equal "vierundvierzig", oo.cell('d',16)
      assert_equal "fuenfundvierzig", oo.cell('e',16)
      assert_equal ["einundvierzig", "zweiundvierzig", "dreiundvierzig", "vierundvierzig", "fuenfundvierzig"], oo.row(16)
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 41, oo.cell('a',12)
      assert_equal 42, oo.cell('b',12)
      assert_equal 43, oo.cell('c',12)
      assert_equal 44, oo.cell('d',12)
      assert_equal 45, oo.cell('e',12)
      assert_equal [41.0,42.0,43.0,44.0,45.0], oo.row(12)
      assert_equal "einundvierzig", oo.cell('a',16)
      assert_equal "zweiundvierzig", oo.cell('b',16)
      assert_equal "dreiundvierzig", oo.cell('c',16)
      assert_equal "vierundvierzig", oo.cell('d',16)
      assert_equal "fuenfundvierzig", oo.cell('e',16)
      assert_equal ["einundvierzig", "zweiundvierzig", "dreiundvierzig", "vierundvierzig", "fuenfundvierzig"], oo.row(16)
    end
    if EXCEL
      #-- Excel
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = oo.sheets.first
      assert_equal 41, oo.cell('a',12)
      assert_equal 42, oo.cell('b',12)
      assert_equal 43, oo.cell('c',12)
      assert_equal 44, oo.cell('d',12)
      assert_equal 45, oo.cell('e',12)
      assert_equal [41,42,43,44,45], oo.row(12)
      assert_equal "einundvierzig", oo.cell('a',16)
      assert_equal "zweiundvierzig", oo.cell('b',16)
      assert_equal "dreiundvierzig", oo.cell('c',16)
      assert_equal "vierundvierzig", oo.cell('d',16)
      assert_equal "fuenfundvierzig", oo.cell('e',16)
      assert_equal ["einundvierzig",
        "zweiundvierzig",
        "dreiundvierzig",
        "vierundvierzig",
        "fuenfundvierzig"], oo.row(16)
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal 41, oo.cell('a',12)
      assert_equal 42, oo.cell('b',12)
      assert_equal 43, oo.cell('c',12)
      assert_equal 44, oo.cell('d',12)
      assert_equal 45, oo.cell('e',12)
      assert_equal [41,42,43,44,45], oo.row(12)
      assert_equal "einundvierzig", oo.cell('a',16)
      assert_equal "zweiundvierzig", oo.cell('b',16)
      assert_equal "dreiundvierzig", oo.cell('c',16)
      assert_equal "vierundvierzig", oo.cell('d',16)
      assert_equal "fuenfundvierzig", oo.cell('e',16)
      assert_equal ["einundvierzig",
        "zweiundvierzig",
        "dreiundvierzig",
        "vierundvierzig",
        "fuenfundvierzig"], oo.row(16)
    end
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      oo.default_sheet = oo.sheets.first
      assert_equal 41, oo.cell('a',12)
      assert_equal 42, oo.cell('b',12)
      assert_equal 43, oo.cell('c',12)
      assert_equal 44, oo.cell('d',12)
      assert_equal 45, oo.cell('e',12)
      assert_equal [41,42,43,44,45], oo.row(12)
      assert_equal "einundvierzig", oo.cell('a',16)
      assert_equal "zweiundvierzig", oo.cell('b',16)
      assert_equal "dreiundvierzig", oo.cell('c',16)
      assert_equal "vierundvierzig", oo.cell('d',16)
      assert_equal "fuenfundvierzig", oo.cell('e',16)
      assert_equal ["einundvierzig",
        "zweiundvierzig",
        "dreiundvierzig",
        "vierundvierzig",
        "fuenfundvierzig"], oo.row(16)
    end
  end

  def test_last_row
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 18, oo.last_row
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 18, oo.last_row
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = oo.sheets.first
      assert_equal 18, oo.last_row
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal 18, oo.last_row
    end
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      oo.default_sheet = oo.sheets.first
      assert_equal 18, oo.last_row
    end
  end

  def test_last_column
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 7, oo.last_column
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 7, oo.last_column
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = oo.sheets.first
      assert_equal 7, oo.last_column
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal 7, oo.last_column
    end
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      oo.default_sheet = oo.sheets.first
      assert_equal 7, oo.last_column
    end
  end

  def test_last_column_as_letter
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 'G', oo.last_column_as_letter
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 'G', oo.last_column_as_letter
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = 1 # oo.sheets.first
      assert_equal 'G', oo.last_column_as_letter
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal 'G', oo.last_column_as_letter
    end
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      oo.default_sheet = oo.sheets.first
      assert_equal 'G', oo.last_column_as_letter
    end
  end

  def test_first_row
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.first_row
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.first_row
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = 1 # oo.sheets.first
      assert_equal 1, oo.first_row
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.first_row
    end
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.first_row
    end
  end

  def test_first_column
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.first_column
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.first_column
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = 1 # oo.sheets.first
      assert_equal 1, oo.first_column
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.first_column
    end
    if GOOGLE
      assert_nothing_raised(Timeout::Error) {
        Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
          oo = Google.new(key_of("numbers1"))
          oo.default_sheet = oo.sheets.first
          assert_equal 1, oo.first_column
        end
      }
    end
  end

  def test_first_column_as_letter_openoffice
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 'A', oo.first_column_as_letter
    end
  end

  def test_first_column_as_letter_gnumeric_ods
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 'A', oo.first_column_as_letter
    end
  end

  def test_first_column_as_letter_excel
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = 1 # oo.sheets.first
      assert_equal 'A', oo.first_column_as_letter
    end
  end

  def test_first_column_as_letter_excelx
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal 'A', oo.first_column_as_letter
    end
  end

  def test_first_column_as_letter_google
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      oo.default_sheet = oo.sheets.first
      assert_equal 'A', oo.first_column_as_letter
    end
  end

  def test_sheetname
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = "Name of Sheet 2"
      assert_equal 'I am sheet 2', oo.cell('C',5)
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = "Name of Sheet 2"
      assert_equal 'I am sheet 2', oo.cell('C',5)
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = "Name of Sheet 2"
      assert_equal 'I am sheet 2', oo.cell('C',5)
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = "Name of Sheet 2"
      assert_equal 'I am sheet 2', oo.cell('C',5)
    end
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      oo.default_sheet = "Name of Sheet 2"
      assert_equal 'I am sheet 2', oo.cell('C',5)
    end
  end

  def test_boundaries
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = "Name of Sheet 2"
      assert_equal 2, oo.first_column
      assert_equal 'B', oo.first_column_as_letter
      assert_equal 5, oo.first_row
      assert_equal 'E', oo.last_column_as_letter
      assert_equal 14, oo.last_row
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = "Name of Sheet 2"
      assert_equal 2, oo.first_column
      assert_equal 'B', oo.first_column_as_letter
      assert_equal 5, oo.first_row
      assert_equal 'E', oo.last_column_as_letter
      assert_equal 14, oo.last_row
    end
    if EXCEL
      #-- Excel
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = 2 # "Name of Sheet 2"
      assert_equal 2, oo.first_column
      assert_equal 'B', oo.first_column_as_letter
      assert_equal 5, oo.first_row
      assert_equal 'E', oo.last_column_as_letter
      assert_equal 14, oo.last_row
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = "Name of Sheet 2"
      assert_equal 2, oo.first_column
      assert_equal 'B', oo.first_column_as_letter
      assert_equal 5, oo.first_row
      assert_equal 'E', oo.last_column_as_letter
      assert_equal 14, oo.last_row
    end
  end

  def test_multiple_letters
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = "Sheet3"
      assert_equal "i am AA", oo.cell('AA',1)
      assert_equal "i am AB", oo.cell('AB',1)
      assert_equal "i am BA", oo.cell('BA',1)
      assert_equal 'BA', oo.last_column_as_letter
      assert_equal "i am BA", oo.cell(1,'BA')
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = "Sheet3"
      assert_equal "i am AA", oo.cell('AA',1)
      assert_equal "i am AB", oo.cell('AB',1)
      assert_equal "i am BA", oo.cell('BA',1)
      assert_equal 'BA', oo.last_column_as_letter
      assert_equal "i am BA", oo.cell(1,'BA')
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = 3 # "Sheet3"
      assert_equal "i am AA", oo.cell('AA',1)
      assert_equal "i am AB", oo.cell('AB',1)
      assert_equal "i am BA", oo.cell('BA',1)
      assert_equal 'BA', oo.last_column_as_letter
      assert_equal "i am BA", oo.cell(1,'BA')
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = "Sheet3"
      assert_equal "i am AA", oo.cell('AA',1)
      assert_equal "i am AB", oo.cell('AB',1)
      assert_equal "i am BA", oo.cell('BA',1)
      assert_equal 'BA', oo.last_column_as_letter
      assert_equal "i am BA", oo.cell(1,'BA')
    end
  end

  def test_argument_error
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      before Date.new(2007,7,20) do
        assert_raise(ArgumentError) {
          #oo.default_sheet = "first sheet"
          oo.default_sheet = "Tabelle1"
        }
      end
      assert_nothing_raised(ArgumentError) {
        # oo.default_sheet = 1
        #oo.default_sheet = "first sheet"
        oo.default_sheet = "Tabelle1"
      }
    end
  end

  def test_empty_eh
    if OPENOFFICE #-- OpenOffice
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert oo.empty?('a',14)
      assert ! oo.empty?('a',15)
      assert oo.empty?('a',20)
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert oo.empty?('a',14)
      assert ! oo.empty?('a',15)
      assert oo.empty?('a',20)
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = 1
      assert oo.empty?('a',14)
      assert ! oo.empty?('a',15)
      assert oo.empty?('a',20)
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert oo.empty?('a',14)
      assert ! oo.empty?('a',15)
      assert oo.empty?('a',20)
    end
  end

  def test_writeopenoffice
    if OPENOFFICEWRITE
      File.cp(File.join("test","numbers1.ods"),
        File.join("test","numbers2.ods"))
      File.cp(File.join("test","numbers2.ods"),
        File.join("test","bak_numbers2.ods"))
      oo = Openoffice.new(File.join("test","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 = Openoffice.new(File.join("test","numbers2.ods"))
      oo2 = Openoffice.new(File.join("test","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("test","bak_numbers2.ods"),
        File.join("test","numbers2.ods"))
    end
  end

  def test_reload
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.cell(1,1)

      oo.reload
      assert_equal 1, oo.cell(1,1)
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.cell(1,1)

      oo.reload
      assert_equal 1, oo.cell(1,1)
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = 1 # oo.sheets.first
      assert_equal 1, oo.cell(1,1)

      oo.reload
      assert_equal 1, oo.cell(1,1)
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.cell(1,1)

      oo.reload
      assert_equal 1, oo.cell(1,1)
    end
  end

  def test_bug_contiguous_cells
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = "Sheet4"
      assert_equal Date.new(2007,06,16), oo.cell('a',1)
      assert_equal 10, oo.cell('b',1)
      assert_equal 10, oo.cell('c',1)
      assert_equal 10, oo.cell('d',1)
      assert_equal 10, oo.cell('e',1)
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = "Sheet4"
      assert_equal Date.new(2007,06,16), oo.cell('a',1)
      assert_equal 10, oo.cell('b',1)
      assert_equal 10, oo.cell('c',1)
      assert_equal 10, oo.cell('d',1)
      assert_equal 10, oo.cell('e',1)
    end
    #if EXCEL
    #  # dieser Test ist fuer Excel sheets eigentlich nicht noetig,
    #  # da der Bug nur bei OO-Dokumenten auftrat
    #  oo = Excel.new(File.join("test","numbers1.xls"))
    #  oo.default_sheet = 4
    #  assert_equal Date.new(2007,06,16), oo.cell('a',1)
    #  assert_equal 10, oo.cell('b',1)
    #  assert_equal 10, oo.cell('c',1)
    #  assert_equal 10, oo.cell('d',1)
    #  assert_equal 10, oo.cell('e',1)
    #end
    #if GOOGLE
    #  # dieser Test ist fuer Google sheets eigentlich nicht noetig,
    #  # da der Bug nur bei OO-Dokumenten auftrat
    #  oo = Google.new(key_of("numbers1"))
    #  #oo.sheetlist # TODO: refactor me!
    #  oo.default_sheet = "Sheet4"
    #  assert_equal Date.new(2007,06,16), oo.cell('a',1)
    #  assert_equal 10, oo.cell('b',1)
    #  assert_equal 10, oo.cell('c',1)
    #  assert_equal 10, oo.cell('d',1)
    #  assert_equal 10, oo.cell('e',1)
    #end
  end

  def test_bug_italo_ve
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = "Sheet5"
      assert_equal 1, oo.cell('A',1)
      assert_equal 5, oo.cell('b',1)
      assert_equal 5, oo.cell('c',1)
      assert_equal 2, oo.cell('a',2)
      assert_equal 3, oo.cell('a',3)
    end
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = "Sheet5"
      assert_equal 1, oo.cell('A',1)
      assert_equal 5, oo.cell('b',1)
      assert_equal 5, oo.cell('c',1)
      assert_equal 2, oo.cell('a',2)
      assert_equal 3, oo.cell('a',3)
    end
    if GNUMERIC_ODS
      oo = Openoffice.new(File.join("test","gnumeric_numbers1.ods"))
      oo.default_sheet = "Sheet5"
      assert_equal 1, oo.cell('A',1)
      assert_equal 5, oo.cell('b',1)
      assert_equal 5, oo.cell('c',1)
      assert_equal 2, oo.cell('a',2)
      assert_equal 3, oo.cell('a',3)
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = 5
      assert_equal 1, oo.cell('A',1)
      assert_equal 5, oo.cell('b',1)
      assert_equal 5, oo.cell('c',1)
      assert_equal 2, oo.cell('a',2)
      assert_equal 3, oo.cell('a',3)
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets[5-1]
      assert_equal 1, oo.cell('A',1)
      assert_equal 5, oo.cell('b',1)
      assert_equal 5, oo.cell('c',1)
      assert_equal 2, oo.cell('a',2)
      assert_equal 3, oo.cell('a',3)
    end
    #if GOOGLE
    #  oo = Google.new(key_of("numbers1"))
    #  oo.default_sheet = "Sheet5"
    #  assert_equal 1, oo.cell('A',1)
    #  assert_equal 5, oo.cell('b',1)
    #  assert_equal 5, oo.cell('c',1)
    #  assert_equal 2, oo.cell('a',2)
    #  assert_equal 3, oo.cell('a',3)
    #end
  end

  #2008-01-30
  def test_italo_table
    after Date.new(2008,5,30) do
      local_only do
        oo = Openoffice.new(File.join("test","simple_spreadsheet_from_italo.ods"))
        oo.default_sheet = oo.sheets.first

        assert_equal  '1', oo.cell('A',1)
        assert_equal  '1', oo.cell('B',1)
        assert_equal  '1', oo.cell('C',1)

        # assert_equal  1, oo.cell('A',2)
        # assert_equal  2, oo.cell('B',2)
        # assert_equal  1, oo.cell('C',2)
        # are stored as strings, not numbers

        assert_equal  1, oo.cell('A',2).to_i
        assert_equal  2, oo.cell('B',2).to_i
        assert_equal  1, oo.cell('C',2).to_i

        assert_equal  1, oo.cell('A',3)
        assert_equal  3, oo.cell('B',3)
        assert_equal  1, oo.cell('C',3)

        assert_equal  'A', oo.cell('A',4)
        assert_equal  'A', oo.cell('B',4)
        assert_equal  'A', oo.cell('C',4)

        # assert_equal  '0.01', oo.cell('A',5)
        # assert_equal  '0.01', oo.cell('B',5)
        # assert_equal  '0.01', oo.cell('C',5)
        #
        assert_equal  0.01, oo.cell('A',5)
        assert_equal  0.01, oo.cell('B',5)
        assert_equal  0.01, oo.cell('C',5)

        assert_equal 0.03, oo.cell('a',5)+oo.cell('b',5)+oo.cell('c',5)


        #   1.0

        # Cells values in row 1:
        assert_equal "1:string", oo.cell(1, 1)+":"+oo.celltype(1, 1).to_s
        assert_equal "1:string",oo.cell(1, 2)+":"+oo.celltype(1, 2).to_s
        assert_equal "1:string",oo.cell(1, 3)+":"+oo.celltype(1, 3).to_s

        # Cells values in row 2:
        assert_equal "1:string",oo.cell(2, 1)+":"+oo.celltype(2, 1).to_s
        assert_equal "2:string",oo.cell(2, 2)+":"+oo.celltype(2, 2).to_s
        assert_equal "1:string",oo.cell(2, 3)+":"+oo.celltype(2, 3).to_s

        # Cells values in row 3:
        assert_equal "1.0:float",oo.cell(3, 1).to_s+":"+oo.celltype(3, 1).to_s
        assert_equal "3.0:float",oo.cell(3, 2).to_s+":"+oo.celltype(3, 2).to_s
        assert_equal "1.0:float",oo.cell(3, 3).to_s+":"+oo.celltype(3, 3).to_s

        # Cells values in row 4:
        assert_equal "A:string",oo.cell(4, 1)+":"+oo.celltype(4, 1).to_s
        assert_equal "A:string",oo.cell(4, 2)+":"+oo.celltype(4, 2).to_s
        assert_equal "A:string",oo.cell(4, 3)+":"+oo.celltype(4, 3).to_s

        # Cells values in row 5:
        assert_equal "0.01:percentage",oo.cell(5, 1).to_s+":"+oo.celltype(5, 1).to_s
        assert_equal "0.01:percentage",oo.cell(5, 2).to_s+":"+oo.celltype(5, 2).to_s
        assert_equal "0.01:percentage",oo.cell(5, 3).to_s+":"+oo.celltype(5, 3).to_s

        oo = Excel.new(File.join("test","simple_spreadsheet_from_italo.xls"))
        oo.default_sheet = oo.sheets.first

        assert_equal  '1', oo.cell('A',1)
        assert_equal  '1', oo.cell('B',1)
        assert_equal  '1', oo.cell('C',1)

        # assert_equal  1, oo.cell('A',2)
        # assert_equal  2, oo.cell('B',2)
        # assert_equal  1, oo.cell('C',2)
        # are stored as strings, not numbers

        assert_equal  1, oo.cell('A',2).to_i
        assert_equal  2, oo.cell('B',2).to_i
        assert_equal  1, oo.cell('C',2).to_i

        assert_equal  1, oo.cell('A',3)
        assert_equal  3, oo.cell('B',3)
        assert_equal  1, oo.cell('C',3)

        assert_equal  'A', oo.cell('A',4)
        assert_equal  'A', oo.cell('B',4)
        assert_equal  'A', oo.cell('C',4)

        # assert_equal  '0.01', oo.cell('A',5)
        # assert_equal  '0.01', oo.cell('B',5)
        # assert_equal  '0.01', oo.cell('C',5)
        #
        assert_equal  0.01, oo.cell('A',5)
        assert_equal  0.01, oo.cell('B',5)
        assert_equal  0.01, oo.cell('C',5)

        assert_equal 0.03, oo.cell('a',5)+oo.cell('b',5)+oo.cell('c',5)


        #   1.0

        # Cells values in row 1:
        assert_equal "1:string", oo.cell(1, 1)+":"+oo.celltype(1, 1).to_s
        assert_equal "1:string",oo.cell(1, 2)+":"+oo.celltype(1, 2).to_s
        assert_equal "1:string",oo.cell(1, 3)+":"+oo.celltype(1, 3).to_s

        # Cells values in row 2:
        assert_equal "1:string",oo.cell(2, 1)+":"+oo.celltype(2, 1).to_s
        assert_equal "2:string",oo.cell(2, 2)+":"+oo.celltype(2, 2).to_s
        assert_equal "1:string",oo.cell(2, 3)+":"+oo.celltype(2, 3).to_s

        # Cells values in row 3:
        assert_equal "1.0:float",oo.cell(3, 1).to_s+":"+oo.celltype(3, 1).to_s
        assert_equal "3.0:float",oo.cell(3, 2).to_s+":"+oo.celltype(3, 2).to_s
        assert_equal "1.0:float",oo.cell(3, 3).to_s+":"+oo.celltype(3, 3).to_s

        # Cells values in row 4:
        assert_equal "A:string",oo.cell(4, 1)+":"+oo.celltype(4, 1).to_s
        assert_equal "A:string",oo.cell(4, 2)+":"+oo.celltype(4, 2).to_s
        assert_equal "A:string",oo.cell(4, 3)+":"+oo.celltype(4, 3).to_s

        # Cells values in row 5:
        #assert_equal "0.01:percentage",oo.cell(5, 1).to_s+":"+oo.celltype(5, 1).to_s
        #assert_equal "0.01:percentage",oo.cell(5, 2).to_s+":"+oo.celltype(5, 2).to_s
        #assert_equal "0.01:percentage",oo.cell(5, 3).to_s+":"+oo.celltype(5, 3).to_s
        # why do we get floats here? in the spreadsheet the cells were defined
        # to be percentage
        # TODO: should be fixed
        # the excel gem does not support the cell type 'percentage' these
        # cells are returned to be of the type float.
        assert_equal "0.01:float",oo.cell(5, 1).to_s+":"+oo.celltype(5, 1).to_s
        assert_equal "0.01:float",oo.cell(5, 2).to_s+":"+oo.celltype(5, 2).to_s
        assert_equal "0.01:float",oo.cell(5, 3).to_s+":"+oo.celltype(5, 3).to_s
      end
    end #after
  end

  def test_formula
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","formula.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.cell('A',1)
      assert_equal 2, oo.cell('A',2)
      assert_equal 3, oo.cell('A',3)
      assert_equal 4, oo.cell('A',4)
      assert_equal 5, oo.cell('A',5)
      assert_equal 6, oo.cell('A',6)
      assert_equal 21, oo.cell('A',7)
      assert_equal :formula, oo.celltype('A',7)
      assert_equal "=[Sheet2.A1]", oo.formula('C',7)
      assert_nil oo.formula('A',6)
      assert_equal [[7, 1, "=SUM([.A1:.A6])"],
        [7, 2, "=SUM([.$A$1:.B6])"],
        [7, 3, "=[Sheet2.A1]"],
        [8, 2, "=SUM([.$A$1:.B7])"],
      ], oo.formulas(oo.sheets.first)

      after Date.new(2007,6,25) do
        # setting a cell
        oo.set('A',15, 41)
        assert_equal 41, oo.cell('A',15)
        oo.set('A',16, "41")
        assert_equal "41", oo.cell('A',16)
        oo.set('A',17, 42.5)
        assert_equal 42.5, oo.cell('A',17)
      end
    end
    if defined? excel_supports_formulas
      if EXCEL
        oo = Excel.new(File.join("test","formula.xls"))
        oo.default_sheet = oo.sheets.first
        assert_equal 1, oo.cell('A',1)
        assert_equal 2, oo.cell('A',2)
        assert_equal 3, oo.cell('A',3)
        assert_equal 4, oo.cell('A',4)
        assert_equal 5, oo.cell('A',5)
        assert_equal 6, oo.cell('A',6)
        assert_equal :formula, oo.celltype('A',7)
        assert_equal 21, oo.cell('A',7)
        assert_equal " = [Sheet2.A1]", oo.formula('C',7)
        assert_nil oo.formula('A',6)
        assert_equal [[7, 1, " = SUM([.A1:.A6])"],
          [7, 2, " = SUM([.$A$1:.B6])"],
          [7, 3, " = [Sheet2.A1]"],
          [8, 2, " = SUM([.$A$1:.B7])"],
        ], oo.formulas

        after Date.new(2007,6,25) do
          # setting a cell
          oo.set('A',15, 41)
          assert_equal 41, oo.cell('A',15)
          oo.set('A',16, "41")
          assert_equal "41", oo.cell('A',16)
          oo.set('A',17, 42.5)
          assert_equal 42.5, oo.cell('A',17)
        end

      end
    end
    if GOOGLE
      oo = Google.new(key_of("formula"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.cell('A',1)
      assert_equal 2, oo.cell('A',2)
      assert_equal 3, oo.cell('A',3)
      assert_equal 4, oo.cell('A',4)
      assert_equal 5, oo.cell('A',5)
      assert_equal 6, oo.cell('A',6)
      # assert_equal 21, oo.cell('A',7)
      assert_equal 21.0, oo.cell('A',7) #TODO: better solution Fixnum/Float
      assert_equal :formula, oo.celltype('A',7)
      # assert_equal "=[Sheet2.A1]", oo.formula('C',7)
      # !!! different from formulas in Openoffice
      #was: assert_equal "=sheet2!R[-6]C[-2]", oo.formula('C',7)
      # has Google changed their format of formulas/references to other sheets?
      assert_equal "=Sheet2!R[-6]C[-2]", oo.formula('C',7)
      assert_nil oo.formula('A',6)
      # assert_equal [[7, 1, "=SUM([.A1:.A6])"],
      #   [7, 2, "=SUM([.$A$1:.B6])"],
      #   [7, 3, "=[Sheet2.A1]"],
      #   [8, 2, "=SUM([.$A$1:.B7])"],
      # ], oo.formulas(oo.sheets.first)
      # different format than in openoffice spreadsheets:
      #was:
      # assert_equal [[7, 1, "=SUM(R[-6]C[0]:R[-1]C[0])"],
      #  [7, 2, "=SUM(R1C1:R[-1]C[0])"],
      #  [7, 3, "=sheet2!R[-6]C[-2]"],
      #  [8, 2, "=SUM(R1C1:R[-1]C[0])"]],
      #  oo.formulas(oo.sheets.first)
      assert_equal [[7, 1, "=SUM(R[-6]C:R[-1]C)"],
        [7, 2, "=SUM(R1C1:R[-1]C)"],
        [7, 3, "=Sheet2!R[-6]C[-2]"],
        [8, 2, "=SUM(R1C1:R[-1]C)"]],
        oo.formulas(oo.sheets.first)
    end # GOOGLE
    if EXCELX
      oo = Excelx.new(File.join("test","formula.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal 1, oo.cell('A',1)
      assert_equal 2, oo.cell('A',2)
      assert_equal 3, oo.cell('A',3)
      assert_equal 4, oo.cell('A',4)
      assert_equal 5, oo.cell('A',5)
      assert_equal 6, oo.cell('A',6)
      assert_equal 21, oo.cell('A',7)
      assert_equal :formula, oo.celltype('A',7)
      after Date.new(2008,6,1) do
        #steht nicht in Datei, oder?
        assert_equal "=[Sheet2.A1]", oo.formula('C',7)
      end
      assert_nil oo.formula('A',6)
      # assert_equal [[7, 1, "=SUM([.A1:.A6])"],
      #  [7, 2, "=SUM([.$A$1:.B6])"],
      #[7, 3, "=[Sheet2.A1]"],
      #[8, 2, "=SUM([.$A$1:.B7])"],
      #], oo.formulas(oo.sheets.first)
      assert_equal [[7, 1, 'SUM(A1:A6)'],
        [7, 2, 'SUM($A$1:B6)'],
        # [7, 3, "=[Sheet2.A1]"],
        # [8, 2, "=SUM([.$A$1:.B7])"],
      ], oo.formulas(oo.sheets.first)

      after Date.new(2007,6,25) do
        # setting a cell
        oo.set('A',15, 41)
        assert_equal 41, oo.cell('A',15)
        oo.set('A',16, "41")
        assert_equal "41", oo.cell('A',16)
        oo.set('A',17, 42.5)
        assert_equal 42.5, oo.cell('A',17)
      end
    end
  end

  def test_borders_sheets_openoffice
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","borders.ods"))
      oo.default_sheet = oo.sheets[1]
      assert_equal 6, oo.first_row
      assert_equal 11, oo.last_row
      assert_equal 4, oo.first_column
      assert_equal 8, oo.last_column

      oo.default_sheet = oo.sheets.first
      assert_equal 5, oo.first_row
      assert_equal 10, oo.last_row
      assert_equal 3, oo.first_column
      assert_equal 7, oo.last_column

      oo.default_sheet = oo.sheets[2]
      assert_equal 7, oo.first_row
      assert_equal 12, oo.last_row
      assert_equal 5, oo.first_column
      assert_equal 9, oo.last_column
    end
  end
  def test_borders_sheets_excel
    if EXCEL
      oo = Excel.new(File.join("test","borders.xls"))
      oo.default_sheet = oo.sheets[1]
      assert_equal 6, oo.first_row
      assert_equal 11, oo.last_row
      assert_equal 4, oo.first_column
      assert_equal 8, oo.last_column

      oo.default_sheet = 1 # oo.sheets.first
      assert_equal 5, oo.first_row
      assert_equal 10, oo.last_row
      assert_equal 3, oo.first_column
      assert_equal 7, oo.last_column

      oo.default_sheet = 3 # oo.sheets[2]
      assert_equal 7, oo.first_row
      assert_equal 12, oo.last_row
      assert_equal 5, oo.first_column
      assert_equal 9, oo.last_column
    end
  end

  def test_borders_sheets_excelx
    if EXCELX
      oo = Excelx.new(File.join("test","borders.xlsx"))
      oo.default_sheet = oo.sheets[1]
      assert_equal 6, oo.first_row
      assert_equal 11, oo.last_row
      assert_equal 4, oo.first_column
      assert_equal 8, oo.last_column

      oo.default_sheet = oo.sheets.first
      assert_equal 5, oo.first_row
      assert_equal 10, oo.last_row
      assert_equal 3, oo.first_column
      assert_equal 7, oo.last_column

      oo.default_sheet = oo.sheets[2]
      assert_equal 7, oo.first_row
      assert_equal 12, oo.last_row
      assert_equal 5, oo.first_column
      assert_equal 9, oo.last_column
    end
  end

  def test_borders_sheets_google
    if GOOGLE
      assert_nothing_raised(Timeout::Error) {
        Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
          oo = Google.new(key_of("borders"))
          oo.default_sheet = oo.sheets[0]
          assert_equal oo.sheets.first, oo.default_sheet
          assert_equal 5, oo.first_row
          oo.default_sheet = oo.sheets[1]
          assert_equal 'Sheet2', oo.default_sheet
          assert_equal 6, oo.first_row
          assert_equal 11, oo.last_row
          assert_equal 4, oo.first_column
          assert_equal 8, oo.last_column

          oo.default_sheet = oo.sheets.first
          assert_equal 5, oo.first_row
          assert_equal 10, oo.last_row
          assert_equal 3, oo.first_column
          assert_equal 7, oo.last_column

          oo.default_sheet = oo.sheets[2]
          assert_equal 7, oo.first_row
          assert_equal 12, oo.last_row
          assert_equal 5, oo.first_column
          assert_equal 9, oo.last_column
        end
      }
    end
  end

  def yaml_entry(row,col,type,value)
    "cell_#{row}_#{col}: \n  row: #{row} \n  col: #{col} \n  celltype: #{type} \n  value: #{value} \n"
  end

  def test_to_yaml
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal "--- \n"+yaml_entry(5,1,"date","1961-11-21"), oo.to_yaml({}, 5,1,5,1)
      assert_equal "--- \n"+yaml_entry(8,3,"string","thisisc8"), oo.to_yaml({}, 8,3,8,3)
      assert_equal "--- \n"+yaml_entry(12,3,"float",43.0), oo.to_yaml({}, 12,3,12,3)
      assert_equal \
        "--- \n"+yaml_entry(12,3,"float",43.0) +
        yaml_entry(12,4,"float",44.0) +
        yaml_entry(12,5,"float",45.0), oo.to_yaml({}, 12,3,12)
      assert_equal \
        "--- \n"+yaml_entry(12,3,"float",43.0)+
        yaml_entry(12,4,"float",44.0)+
        yaml_entry(12,5,"float",45.0)+
        yaml_entry(15,3,"float",43.0)+
        yaml_entry(15,4,"float",44.0)+
        yaml_entry(15,5,"float",45.0)+
        yaml_entry(16,3,"string","dreiundvierzig")+
        yaml_entry(16,4,"string","vierundvierzig")+
        yaml_entry(16,5,"string","fuenfundvierzig"), oo.to_yaml({}, 12,3)
      #example: puts oo.to_yaml({}, 12,3)
      #example: puts oo.to_yaml({"probe" => "bodenproben_2007-06-30"}, 12,3)
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = 1
      assert_equal "--- \n"+yaml_entry(5,1,"date","1961-11-21"), oo.to_yaml({}, 5,1,5,1)
      assert_equal "--- \n"+yaml_entry(8,3,"string","thisisc8"), oo.to_yaml({}, 8,3,8,3)
      assert_equal "--- \n"+yaml_entry(12,3,"float",43.0), oo.to_yaml({}, 12,3,12,3)
      assert_equal \
        "--- \n"+yaml_entry(12,3,"float",43.0) +
        yaml_entry(12,4,"float",44.0) +
        yaml_entry(12,5,"float",45.0), oo.to_yaml({}, 12,3,12)
      assert_equal \
        "--- \n"+yaml_entry(12,3,"float",43.0)+
        yaml_entry(12,4,"float",44.0)+
        yaml_entry(12,5,"float",45.0)+
        yaml_entry(15,3,"float",43.0)+
        yaml_entry(15,4,"float",44.0)+
        yaml_entry(15,5,"float",45.0)+
        yaml_entry(16,3,"string","dreiundvierzig")+
        yaml_entry(16,4,"string","vierundvierzig")+
        yaml_entry(16,5,"string","fuenfundvierzig"), oo.to_yaml({}, 12,3)
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal "--- \n"+yaml_entry(5,1,"date","1961-11-21"), oo.to_yaml({}, 5,1,5,1)
      assert_equal "--- \n"+yaml_entry(8,3,"string","thisisc8"), oo.to_yaml({}, 8,3,8,3)
      assert_equal "--- \n"+yaml_entry(12,3,"float",43.0), oo.to_yaml({}, 12,3,12,3)
      assert_equal \
        "--- \n"+yaml_entry(12,3,"float",43.0) +
        yaml_entry(12,4,"float",44.0) +
        yaml_entry(12,5,"float",45.0), oo.to_yaml({}, 12,3,12)
      assert_equal \
        "--- \n"+yaml_entry(12,3,"float",43.0)+
        yaml_entry(12,4,"float",44.0)+
        yaml_entry(12,5,"float",45.0)+
        yaml_entry(15,3,"float",43.0)+
        yaml_entry(15,4,"float",44.0)+
        yaml_entry(15,5,"float",45.0)+
        yaml_entry(16,3,"string","dreiundvierzig")+
        yaml_entry(16,4,"string","vierundvierzig")+
        yaml_entry(16,5,"string","fuenfundvierzig"), oo.to_yaml({}, 12,3)
    end
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      oo.default_sheet = oo.sheets.first
      assert_equal "--- \n"+yaml_entry(5,1,"date","1961-11-21"), oo.to_yaml({}, 5,1,5,1)
      assert_equal "--- \n"+yaml_entry(8,3,"string","thisisc8"), oo.to_yaml({}, 8,3,8,3)
      assert_equal "--- \n"+yaml_entry(12,3,"float",43.0), oo.to_yaml({}, 12,3,12,3)
      assert_equal \
        "--- \n"+yaml_entry(12,3,"float",43.0) +
        yaml_entry(12,4,"float",44.0) +
        yaml_entry(12,5,"float",45.0), oo.to_yaml({}, 12,3,12)
      assert_equal \
        "--- \n"+yaml_entry(12,3,"float",43.0)+
        yaml_entry(12,4,"float",44.0)+
        yaml_entry(12,5,"float",45.0)+
        yaml_entry(15,3,"float",43.0)+
        yaml_entry(15,4,"float",44.0)+
        yaml_entry(15,5,"float",45.0)+
        yaml_entry(16,3,"string","dreiundvierzig")+
        yaml_entry(16,4,"string","vierundvierzig")+
        yaml_entry(16,5,"string","fuenfundvierzig"), oo.to_yaml({}, 12,3)
      #example: puts oo.to_yaml({}, 12,3)
      #example: puts oo.to_yaml({"probe" => "bodenproben_2007-06-30"}, 12,3)
    end
  end

  if false
    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
  end # false

  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("test","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('test','createdspreadsheet.ods')
  #  rm(name) if File.exists?(File.join('test','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("test","createdspreadsheet.ods"),true)
  #  s.set 'a',1,42
  #  s.set 'b',1,43
  #  s.set 'c',1,44
  #  s.save
  #
  #  #after Date.new(2007,7,3) do
  #  #  t = Openoffice.new(File.join("test","createdspreadsheet.ods"))
  #  #  assert_equal 42, t.cell(1,'a')
  #  #  assert_equal 43, t.cell('b',1)
  #  #  assert_equal 44, t.cell('c',3)
  #  #end
  #end

  def test_only_one_sheet
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","only_one_sheet.ods"))
      # oo.default_sheet = oo.sheets.first
      assert_equal 42, oo.cell('B',4)
      assert_equal 43, oo.cell('C',4)
      assert_equal 44, oo.cell('D',4)
      oo.default_sheet = oo.sheets.first
      assert_equal 42, oo.cell('B',4)
      assert_equal 43, oo.cell('C',4)
      assert_equal 44, oo.cell('D',4)
    end
    if EXCEL
      oo = Excel.new(File.join("test","only_one_sheet.xls"))
      # oo.default_sheet = oo.sheets.first
      assert_equal 42, oo.cell('B',4)
      assert_equal 43, oo.cell('C',4)
      assert_equal 44, oo.cell('D',4)
      oo.default_sheet = oo.sheets.first
      assert_equal 42, oo.cell('B',4)
      assert_equal 43, oo.cell('C',4)
      assert_equal 44, oo.cell('D',4)
    end
    if EXCELX
      oo = Excelx.new(File.join("test","only_one_sheet.xlsx"))
      # oo.default_sheet = oo.sheets.first
      assert_equal 42, oo.cell('B',4)
      assert_equal 43, oo.cell('C',4)
      assert_equal 44, oo.cell('D',4)
      oo.default_sheet = oo.sheets.first
      assert_equal 42, oo.cell('B',4)
      assert_equal 43, oo.cell('C',4)
      assert_equal 44, oo.cell('D',4)
    end
    if GOOGLE
      oo = Google.new(key_of("only_one_sheet"))
      # oo.default_sheet = oo.sheets.first
      assert_equal 42, oo.cell('B',4)
      assert_equal 43, oo.cell('C',4)
      assert_equal 44, oo.cell('D',4)
      oo.default_sheet = oo.sheets.first
      assert_equal 42, oo.cell('B',4)
      assert_equal 43, oo.cell('C',4)
      assert_equal 44, oo.cell('D',4)
    end

  end

  def test_excel_open_from_uri_and_zipped
    if EXCEL
      if ONLINE
        url = 'http://stiny-leonhard.de/bode-v1.xls.zip'
        excel = Excel.new(url, :zip)
        assert_equal 'ist "e" im Nenner von H(s)', excel.cell('b', 5)
        excel.remove_tmp # don't forget to remove the temporary files
      end
    end
  end

  #TODO: xlsx-Datei anpassen!
  def test_excelx_open_from_uri_and_zipped
    after Date.new(2008,6,30) do
      if EXCELX
        if ONLINE
          url = 'http://stiny-leonhard.de/bode-v1.xlsx.zip'
          excel = Excelx.new(url, :zip)
          assert_equal 'ist "e" im Nenner von H(s)', excel.cell('b', 5)
          excel.remove_tmp # don't forget to remove the temporary files
        end
      end
    end
  end

  def test_openoffice_open_from_uri_and_zipped
    if OPENOFFICE
      if ONLINE
        url = 'http://spazioinwind.libero.it/s2/rata.ods.zip'
        sheet = Openoffice.new(url, :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
        sheet.remove_tmp # don't forget to remove the temporary files
      end
    end
  end
 
  def test_excel_zipped
    if EXCEL
      excel = Excel.new(File.join("test","bode-v1.xls.zip"), :zip)
      assert excel
      assert_equal 'ist "e" im Nenner von H(s)', excel.cell('b', 5)
      excel.remove_tmp # don't forget to remove the temporary files
    end
  end

  def test_excelx_zipped
    if EXCELX
      after Date.new(2008,6,1) do
        # diese Datei giebte es noch nicht gezippt
        excel = Excelx.new(File.join("test","bode-v1.xlsx.zip"), :zip)
        assert excel
        assert_equal 'ist "e" im Nenner von H(s)', excel.cell('b', 5)
        excel.remove_tmp # don't forget to remove the temporary files
      end
    end
  end

  def test_openoffice_zipped
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","bode-v1.ods.zip"), :zip)
      assert oo
      oo.default_sheet = oo.sheets.first
      assert_equal 'ist "e" im Nenner von H(s)', oo.cell('b', 5)
      oo.remove_tmp # don't forget to remove the temporary files
    end
  end

  def test_bug_ric
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","ric.ods"))
      oo.default_sheet = oo.sheets.first
      assert oo.empty?('A',1)
      assert oo.empty?('B',1)
      assert oo.empty?('C',1)
      assert oo.empty?('D',1)
      expected = 1
      letter = 'e'
      while letter <= 'u'
        assert_equal expected, oo.cell(letter,1)
        letter.succ!
        expected += 1
      end
      #assert_equal 2, oo.cell('f',1)
      #assert_equal 3, oo.cell('g',1)
      #assert_equal 4, oo.cell('h',1)
      #assert_equal 5, oo.cell('i',1)
      #assert_equal 6, oo.cell('j',1)
      #assert_equal 7, oo.cell('k',1)
      #assert_equal 8, oo.cell('l',1)
      #assert_equal 9, oo.cell('m',1)
      #assert_equal 10, oo.cell('n',1)
      #assert_equal 11, oo.cell('o',1)
      #assert_equal 12, oo.cell('p',1)
      #assert_equal 13, oo.cell('q',1)
      #assert_equal 14, oo.cell('r',1)
      #assert_equal 15, oo.cell('s',1)
      #assert_equal 16, oo.cell('t',1)
      #assert_equal 17, oo.cell('u',1)
      assert_equal 'J', oo.cell('v',1)
      assert_equal 'P', oo.cell('w',1)
      assert_equal 'B', oo.cell('x',1)
      assert_equal 'All', oo.cell('y',1)
      assert_equal 0, oo.cell('a',2)
      assert oo.empty?('b',2)
      assert oo.empty?('c',2)
      assert oo.empty?('d',2)

      #'e'.upto('s') {|letter|
      #  assert_equal 'B', oo.cell(letter,2)
      #}
      assert_equal 'B', oo.cell('e',2)
      assert_equal 'B', oo.cell('f',2)
      assert_equal 'B', oo.cell('g',2)
      assert_equal 'B', oo.cell('h',2)
      assert_equal 'B', oo.cell('i',2)
      assert_equal 'B', oo.cell('j',2)
      assert_equal 'B', oo.cell('k',2)
      assert_equal 'B', oo.cell('l',2)
      assert_equal 'B', oo.cell('m',2)
      assert_equal 'B', oo.cell('n',2)
      assert_equal 'B', oo.cell('o',2)
      assert_equal 'B', oo.cell('p',2)
      assert_equal 'B', oo.cell('q',2)
      assert_equal 'B', oo.cell('r',2)
      assert_equal 'B', oo.cell('s',2)

      assert oo.empty?('t',2)
      assert oo.empty?('u',2)
      assert_equal 0  , oo.cell('v',2)
      assert_equal 0  , oo.cell('w',2)
      assert_equal 15 , oo.cell('x',2)
      assert_equal 15 , oo.cell('y',2)
    end
  end

  def test_mehrteilig
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","Bibelbund1.ods"))
      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
    if EXCELX
      after Date.new(2008,6,1) do
        #Datei gibt es noch nicht
        oo = Excelx.new(File.join("test","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
  end

  def test_huge_document_to_csv_openoffice
    if LONG_RUN
      if OPENOFFICE
        assert_nothing_raised(Timeout::Error) {
          Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
            File.delete_if_exist("/tmp/Bibelbund.csv")
            oo = Openoffice.new(File.join("test","Bibelbund.ods"))
            oo.default_sheet = oo.sheets.first
            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("/tmp/Bibelbund.csv")
            assert File.exists?("/tmp/Bibelbund.csv")
            assert_equal "", `diff test/Bibelbund.csv /tmp/Bibelbund.csv`
          end # Timeout
        } # nothing_raised
      end # OPENOFFICE
    end
  end

  def test_huge_document_to_csv_excel
    if LONG_RUN
      if EXCEL
        assert_nothing_raised(Timeout::Error) {
          Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
            File.delete("/tmp/Bibelbund.csv")
            oo = Excel.new(File.join("test","Bibelbund.xls"))
            oo.default_sheet = oo.sheets.first
            assert oo.to_csv("/tmp/Bibelbund.csv")
            assert File.exists?("/tmp/Bibelbund.csv")
            assert_equal "", `diff test/Bibelbund.csv /tmp/Bibelbund.csv`
          end
        }
      end
    end # LONG_RUN
  end # def to_csv

  def test_huge_document_to_csv_excelx
    if LONG_RUN
      if EXCELX
        assert_nothing_raised(Timeout::Error) {
          Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
            File.delete("/tmp/Bibelbund.csv")
            oo = Excelx.new(File.join("test","Bibelbund.xlsx"))
            oo.default_sheet = oo.sheets.first
            assert oo.to_csv("/tmp/Bibelbund.csv")
            assert File.exists?("/tmp/Bibelbund.csv")
            assert_equal "", `diff test/Bibelbund.csv /tmp/Bibelbund.csv`
          end
        }
      end
    end # LONG_RUN
  end # def to_csv

  def test_huge_document_to_csv_google
    # maybe a better example... TODO:
    after Date.new(2008,1,30) do
      if GOOGLE and LONG_RUN
        assert_nothing_raised(Timeout::Error) {
          Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
            File.delete("/tmp/numbers1.csv") if File.exists?("/tmp/numbers1.csv")
            oo = Google.new(key_of('numbers1'))
            oo.default_sheet = oo.sheets.first
            #?? 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("/tmp/numbers1.csv")
            assert File.exists?("/tmp/numbers1.csv")
            assert_equal "", `diff test/numbers1.csv /tmp/numbers1.csv`
          end # Timeout
        } # nothing_raised
      end # GOOGLE
    end # after
  end

  def test_to_csv_openoffice
    if OPENOFFICE
      #assert_nothing_raised(Timeout::Error) {
      Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
        File.delete_if_exist("/tmp/numbers1.csv")
        oo = Openoffice.new(File.join("test","numbers1.ods"))


        # bug?, 2008-01-15 from Troy Davis
        assert oo.to_csv("/tmp/numbers1.csv",oo.sheets.first)
        assert File.exists?("/tmp/numbers1.csv")
        assert_equal "", `diff test/numbers1.csv /tmp/numbers1.csv`

        oo.default_sheet = oo.sheets.first
        assert oo.to_csv("/tmp/numbers1.csv")
        assert File.exists?("/tmp/numbers1.csv")
        assert_equal "", `diff test/numbers1.csv /tmp/numbers1.csv`

      end # Timeout
      #} # nothing_raised
    end # OPENOFFICE
  end

  def test_to_csv_excel
    if EXCEL
      #assert_nothing_raised(Timeout::Error) {
      Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
        File.delete_if_exist("/tmp/numbers1_excel.csv")
        oo = Excel.new(File.join("test","numbers1.xls"))

        # bug?, 2008-01-15 from Troy Davis
        assert oo.to_csv("/tmp/numbers1_excel.csv",oo.sheets.first)
        assert File.exists?("/tmp/numbers1_excel.csv")
        assert_equal "", `diff test/numbers1_excel.csv /tmp/numbers1_excel.csv`
        oo.default_sheet = oo.sheets.first
        assert oo.to_csv("/tmp/numbers1_excel.csv")
        assert File.exists?("/tmp/numbers1_excel.csv")
        assert_equal "", `diff test/numbers1_excel.csv /tmp/numbers1_excel.csv`
      end

      #}
    end
  end # def to_csv

  def test_to_csv_excelx
    if EXCELX
      #assert_nothing_raised(Timeout::Error) {
      Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
        File.delete_if_exist("/tmp/numbers1.csv")
        oo = Excelx.new(File.join("test","numbers1.xlsx"))

        # bug?, 2008-01-15 from Troy Davis
        assert oo.to_csv("/tmp/numbers1.csv",oo.sheets.first)
        assert File.exists?("/tmp/numbers1.csv")
        assert_equal "", `diff test/numbers1.csv /tmp/numbers1.csv`
        oo.default_sheet = oo.sheets.first
        assert oo.to_csv("/tmp/numbers1.csv")
        assert File.exists?("/tmp/numbers1.csv")
        assert_equal "", `diff test/numbers1.csv /tmp/numbers1.csv`
      end

      #}
    end
  end # def to_csv
 
  def test_to_csv_google
    # maybe a better example... TODO:
    after Date.new(2008,3,30) do
      if GOOGLE
        #assert_nothing_raised(Timeout::Error) {
        Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
          File.delete_if_exist("/tmp/numbers1.csv") if File.exists?("/tmp/numbers1.csv")
          oo = Google.new(key_of('numbers1'))

          oo.default_sheet = oo.sheets.first
          assert oo.to_csv("/tmp/numbers1.csv")
          assert File.exists?("/tmp/numbers1.csv")
          assert_equal "", `diff test/numbers1.csv /tmp/numbers1.csv`

          # bug?, 2008-01-15 from Troy Davis
          assert oo.to_csv("/tmp/numbers1.csv",oo.sheets.first)
          assert File.exists?("/tmp/numbers1.csv")
          assert_equal "", `diff test/numbers1.csv /tmp/numbers1.csv`

        end # Timeout
        #} # nothing_raised
      end # GOOGLE
    end # after
  end

  def test_bug_mehrere_datum
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = 'Sheet5'
      assert_equal :date, oo.celltype('A',4)
      assert_equal :date, oo.celltype('B',4)
      assert_equal :date, oo.celltype('C',4)
      assert_equal :date, oo.celltype('D',4)
      assert_equal :date, oo.celltype('E',4)
      assert_equal Date.new(2007,11,21), oo.cell('A',4)
      assert_equal Date.new(2007,11,21), oo.cell('B',4)
      assert_equal Date.new(2007,11,21), oo.cell('C',4)
      assert_equal Date.new(2007,11,21), oo.cell('D',4)
      assert_equal Date.new(2007,11,21), oo.cell('E',4)
      assert_equal :float, oo.celltype('A',5)
      assert_equal :float, oo.celltype('B',5)
      assert_equal :float, oo.celltype('C',5)
      assert_equal :float, oo.celltype('D',5)
      assert_equal :float, oo.celltype('E',5)
      assert_equal 42, oo.cell('A',5)
      assert_equal 42, oo.cell('B',5)
      assert_equal 42, oo.cell('C',5)
      assert_equal 42, oo.cell('D',5)
      assert_equal 42, oo.cell('E',5)
      assert_equal :string, oo.celltype('A',6)
      assert_equal :string, oo.celltype('B',6)
      assert_equal :string, oo.celltype('C',6)
      assert_equal :string, oo.celltype('D',6)
      assert_equal :string, oo.celltype('E',6)
      assert_equal "ABC", oo.cell('A',6)
      assert_equal "ABC", oo.cell('B',6)
      assert_equal "ABC", oo.cell('C',6)
      assert_equal "ABC", oo.cell('D',6)
      assert_equal "ABC", oo.cell('E',6)
    end # Openoffice

    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = 'Sheet5'
      assert_equal :date, oo.celltype('A',4)
      assert_equal :date, oo.celltype('B',4)
      assert_equal :date, oo.celltype('C',4)
      assert_equal :date, oo.celltype('D',4)
      assert_equal :date, oo.celltype('E',4)
      assert_equal Date.new(2007,11,21), oo.cell('A',4)
      assert_equal Date.new(2007,11,21), oo.cell('B',4)
      assert_equal Date.new(2007,11,21), oo.cell('C',4)
      assert_equal Date.new(2007,11,21), oo.cell('D',4)
      assert_equal Date.new(2007,11,21), oo.cell('E',4)
      assert_equal :float, oo.celltype('A',5)
      assert_equal :float, oo.celltype('B',5)
      assert_equal :float, oo.celltype('C',5)
      assert_equal :float, oo.celltype('D',5)
      assert_equal :float, oo.celltype('E',5)
      assert_equal 42, oo.cell('A',5)
      assert_equal 42, oo.cell('B',5)
      assert_equal 42, oo.cell('C',5)
      assert_equal 42, oo.cell('D',5)
      assert_equal 42, oo.cell('E',5)
      assert_equal :string, oo.celltype('A',6)
      assert_equal :string, oo.celltype('B',6)
      assert_equal :string, oo.celltype('C',6)
      assert_equal :string, oo.celltype('D',6)
      assert_equal :string, oo.celltype('E',6)
      assert_equal "ABC", oo.cell('A',6)
      assert_equal "ABC", oo.cell('B',6)
      assert_equal "ABC", oo.cell('C',6)
      assert_equal "ABC", oo.cell('D',6)
      assert_equal "ABC", oo.cell('E',6)
    end # Excel
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = 'Sheet5'
      assert_equal :date, oo.celltype('A',4)
      assert_equal :date, oo.celltype('B',4)
      assert_equal :date, oo.celltype('C',4)
      assert_equal :date, oo.celltype('D',4)
      assert_equal :date, oo.celltype('E',4)
      assert_equal Date.new(2007,11,21), oo.cell('A',4)
      assert_equal Date.new(2007,11,21), oo.cell('B',4)
      assert_equal Date.new(2007,11,21), oo.cell('C',4)
      assert_equal Date.new(2007,11,21), oo.cell('D',4)
      assert_equal Date.new(2007,11,21), oo.cell('E',4)
      assert_equal :float, oo.celltype('A',5)
      assert_equal :float, oo.celltype('B',5)
      assert_equal :float, oo.celltype('C',5)
      assert_equal :float, oo.celltype('D',5)
      assert_equal :float, oo.celltype('E',5)
      assert_equal 42, oo.cell('A',5)
      assert_equal 42, oo.cell('B',5)
      assert_equal 42, oo.cell('C',5)
      assert_equal 42, oo.cell('D',5)
      assert_equal 42, oo.cell('E',5)
      assert_equal :string, oo.celltype('A',6)
      assert_equal :string, oo.celltype('B',6)
      assert_equal :string, oo.celltype('C',6)
      assert_equal :string, oo.celltype('D',6)
      assert_equal :string, oo.celltype('E',6)
      assert_equal "ABC", oo.cell('A',6)
      assert_equal "ABC", oo.cell('B',6)
      assert_equal "ABC", oo.cell('C',6)
      assert_equal "ABC", oo.cell('D',6)
      assert_equal "ABC", oo.cell('E',6)
    end # Excelx
  end

  def test_multiple_sheets
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      2.times do
        oo.default_sheet = "Tabelle1"
        assert_equal 1, oo.cell(1,1)
        assert_equal 1, oo.cell(1,1,"Tabelle1")
        assert_equal "I am sheet 2", oo.cell('C',5,"Name of Sheet 2")
        sheetname = 'Sheet5'
        assert_equal :date, oo.celltype('A',4,sheetname)
        assert_equal :date, oo.celltype('B',4,sheetname)
        assert_equal :date, oo.celltype('C',4,sheetname)
        assert_equal :date, oo.celltype('D',4,sheetname)
        assert_equal :date, oo.celltype('E',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('A',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('B',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('C',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('D',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('E',4,sheetname)
        assert_equal :float, oo.celltype('A',5,sheetname)
        assert_equal :float, oo.celltype('B',5,sheetname)
        assert_equal :float, oo.celltype('C',5,sheetname)
        assert_equal :float, oo.celltype('D',5,sheetname)
        assert_equal :float, oo.celltype('E',5,sheetname)
        assert_equal 42, oo.cell('A',5,sheetname)
        assert_equal 42, oo.cell('B',5,sheetname)
        assert_equal 42, oo.cell('C',5,sheetname)
        assert_equal 42, oo.cell('D',5,sheetname)
        assert_equal 42, oo.cell('E',5,sheetname)
        assert_equal :string, oo.celltype('A',6,sheetname)
        assert_equal :string, oo.celltype('B',6,sheetname)
        assert_equal :string, oo.celltype('C',6,sheetname)
        assert_equal :string, oo.celltype('D',6,sheetname)
        assert_equal :string, oo.celltype('E',6,sheetname)
        assert_equal "ABC", oo.cell('A',6,sheetname)
        assert_equal "ABC", oo.cell('B',6,sheetname)
        assert_equal "ABC", oo.cell('C',6,sheetname)
        assert_equal "ABC", oo.cell('D',6,sheetname)
        assert_equal "ABC", oo.cell('E',6,sheetname)
        oo.reload
      end
    end
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      2.times do
        oo.default_sheet = "Tabelle1"
        assert_equal 1, oo.cell(1,1)
        assert_equal 1, oo.cell(1,1,"Tabelle1")
        assert_equal "I am sheet 2", oo.cell('C',5,"Name of Sheet 2")
        sheetname = 'Sheet5'
        assert_equal :date, oo.celltype('A',4,sheetname)
        assert_equal :date, oo.celltype('B',4,sheetname)
        assert_equal :date, oo.celltype('C',4,sheetname)
        assert_equal :date, oo.celltype('D',4,sheetname)
        assert_equal :date, oo.celltype('E',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('A',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('B',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('C',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('D',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('E',4,sheetname)
        assert_equal :float, oo.celltype('A',5,sheetname)
        assert_equal :float, oo.celltype('B',5,sheetname)
        assert_equal :float, oo.celltype('C',5,sheetname)
        assert_equal :float, oo.celltype('D',5,sheetname)
        assert_equal :float, oo.celltype('E',5,sheetname)
        assert_equal 42, oo.cell('A',5,sheetname)
        assert_equal 42, oo.cell('B',5,sheetname)
        assert_equal 42, oo.cell('C',5,sheetname)
        assert_equal 42, oo.cell('D',5,sheetname)
        assert_equal 42, oo.cell('E',5,sheetname)
        assert_equal :string, oo.celltype('A',6,sheetname)
        assert_equal :string, oo.celltype('B',6,sheetname)
        assert_equal :string, oo.celltype('C',6,sheetname)
        assert_equal :string, oo.celltype('D',6,sheetname)
        assert_equal :string, oo.celltype('E',6,sheetname)
        assert_equal "ABC", oo.cell('A',6,sheetname)
        assert_equal "ABC", oo.cell('B',6,sheetname)
        assert_equal "ABC", oo.cell('C',6,sheetname)
        assert_equal "ABC", oo.cell('D',6,sheetname)
        assert_equal "ABC", oo.cell('E',6,sheetname)
        oo.reload
      end
    end
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      2.times do
        oo.default_sheet = "Tabelle1"
        assert_equal 1, oo.cell(1,1)
        assert_equal 1, oo.cell(1,1,"Tabelle1")
        assert_equal "I am sheet 2", oo.cell('C',5,"Name of Sheet 2")
        sheetname = 'Sheet5'
        assert_equal :date, oo.celltype('A',4,sheetname)
        assert_equal :date, oo.celltype('B',4,sheetname)
        assert_equal :date, oo.celltype('C',4,sheetname)
        assert_equal :date, oo.celltype('D',4,sheetname)
        assert_equal :date, oo.celltype('E',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('A',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('B',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('C',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('D',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('E',4,sheetname)
        assert_equal :float, oo.celltype('A',5,sheetname)
        assert_equal :float, oo.celltype('B',5,sheetname)
        assert_equal :float, oo.celltype('C',5,sheetname)
        assert_equal :float, oo.celltype('D',5,sheetname)
        assert_equal :float, oo.celltype('E',5,sheetname)
        assert_equal 42, oo.cell('A',5,sheetname)
        assert_equal 42, oo.cell('B',5,sheetname)
        assert_equal 42, oo.cell('C',5,sheetname)
        assert_equal 42, oo.cell('D',5,sheetname)
        assert_equal 42, oo.cell('E',5,sheetname)
        assert_equal :string, oo.celltype('A',6,sheetname)
        assert_equal :string, oo.celltype('B',6,sheetname)
        assert_equal :string, oo.celltype('C',6,sheetname)
        assert_equal :string, oo.celltype('D',6,sheetname)
        assert_equal :string, oo.celltype('E',6,sheetname)
        assert_equal "ABC", oo.cell('A',6,sheetname)
        assert_equal "ABC", oo.cell('B',6,sheetname)
        assert_equal "ABC", oo.cell('C',6,sheetname)
        assert_equal "ABC", oo.cell('D',6,sheetname)
        assert_equal "ABC", oo.cell('E',6,sheetname)
        oo.reload
      end
    end
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      2.times do
        oo.default_sheet = "Tabelle1"
        assert_equal 1, oo.cell(1,1)
        assert_equal 1, oo.cell(1,1,"Tabelle1")
        assert_equal "I am sheet 2", oo.cell('C',5,"Name of Sheet 2")
        sheetname = 'Sheet5'
        assert_equal :date, oo.celltype('A',4,sheetname)
        assert_equal :date, oo.celltype('B',4,sheetname)
        assert_equal :date, oo.celltype('C',4,sheetname)
        assert_equal :date, oo.celltype('D',4,sheetname)
        assert_equal :date, oo.celltype('E',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('A',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('B',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('C',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('D',4,sheetname)
        assert_equal Date.new(2007,11,21), oo.cell('E',4,sheetname)
        assert_equal :float, oo.celltype('A',5,sheetname)
        assert_equal :float, oo.celltype('B',5,sheetname)
        assert_equal :float, oo.celltype('C',5,sheetname)
        assert_equal :float, oo.celltype('D',5,sheetname)
        assert_equal :float, oo.celltype('E',5,sheetname)
        assert_equal 42, oo.cell('A',5,sheetname)
        assert_equal 42, oo.cell('B',5,sheetname)
        assert_equal 42, oo.cell('C',5,sheetname)
        assert_equal 42, oo.cell('D',5,sheetname)
        assert_equal 42, oo.cell('E',5,sheetname)
        assert_equal :string, oo.celltype('A',6,sheetname)
        assert_equal :string, oo.celltype('B',6,sheetname)
        assert_equal :string, oo.celltype('C',6,sheetname)
        assert_equal :string, oo.celltype('D',6,sheetname)
        assert_equal :string, oo.celltype('E',6,sheetname)
        assert_equal "ABC", oo.cell('A',6,sheetname)
        assert_equal "ABC", oo.cell('B',6,sheetname)
        assert_equal "ABC", oo.cell('C',6,sheetname)
        assert_equal "ABC", oo.cell('D',6,sheetname)
        assert_equal "ABC", oo.cell('E',6,sheetname)
        oo.reload
      end
    end
  end

  def test_bug_empty_sheet_openoffice
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","formula.ods"))
      oo.default_sheet = 'Sheet3' # is an empty sheet
      assert_nothing_raised(NoMethodError) {
        oo.to_csv(File.join("/","tmp","emptysheet.csv"))
      }
      assert_equal "", `cat /tmp/emptysheet.csv`
    end
  end
  
  def test_bug_empty_sheet_excelx
    after Date.new(2008,5,22) do
      if EXCELX
        oo = Excelx.new(File.join("test","formula.xlsx"))
        oo.default_sheet = 'Sheet3' # is an empty sheet
        assert_nothing_raised(NoMethodError) {
          oo.to_csv(File.join("/","tmp","emptysheet.csv"))
        }
        assert_equal "", `cat /tmp/emptysheet.csv`
      end
    end
  end
  
  def test_find_by_row_huge_document_openoffice
    if LONG_RUN
      if OPENOFFICE
        Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
          oo = Openoffice.new(File.join("test","Bibelbund.ods"))
          oo.default_sheet = oo.sheets.first
          rec = oo.find 20
          assert rec
          # assert_equal "Brief aus dem Sekretariat", rec[0]
          #p rec
          assert_equal "Brief aus dem Sekretariat", rec[0]['TITEL']

          rec = oo.find 22
          assert rec
          # assert_equal "Brief aus dem Skretariat. Tagung in Amberg/Opf.",rec[0]
          assert_equal "Brief aus dem Skretariat. Tagung in Amberg/Opf.",rec[0]['TITEL']
        end
      end
    end
  end

  def test_find_by_row_huge_document_excel
    if LONG_RUN
      if EXCEL
        Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
          oo = Excel.new(File.join("test","Bibelbund.xls"))
          oo.default_sheet = oo.sheets.first
          rec = oo.find 20
          assert rec
          assert_equal "Brief aus dem Sekretariat", rec[0]

          rec = oo.find 22
          assert rec
          assert_equal "Brief aus dem Skretariat. Tagung in Amberg/Opf.",rec[0]
        end
      end
    end
  end

  def test_find_by_row_huge_document_excelx
    if LONG_RUN
      if EXCEL
        Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
          oo = Excelx.new(File.join("test","Bibelbund.xlsx"))
          oo.default_sheet = oo.sheets.first
          rec = oo.find 20
          assert rec
          assert_equal "Brief aus dem Sekretariat", rec[0]

          rec = oo.find 22
          assert rec
          assert_equal "Brief aus dem Skretariat. Tagung in Amberg/Opf.",rec[0]
        end
      end
    end
  end

  def test_find_by_row_openoffice
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      oo.default_sheet = oo.sheets.first
      oo.header_line = nil
      rec = oo.find 16
      assert rec
      assert_nil oo.header_line
      # keine Headerlines in diesem Beispiel definiert
      assert_equal "einundvierzig", rec[0]
      #assert_equal false, rec

      rec = oo.find 15
      assert rec
      assert_equal 41,rec[0]
    end
  end

  def test_find_by_row_excel
    if EXCEL
      oo = Excel.new(File.join("test","numbers1.xls"))
      oo.default_sheet = oo.sheets.first
      oo.header_line = nil
      rec = oo.find 16
      assert rec
      # keine Headerlines in diesem Beispiel definiert
      assert_equal "einundvierzig", rec[0]

      rec = oo.find 15
      assert rec
      assert_equal 41,rec[0]
    end
  end

  def test_find_by_row_excelx
    if EXCELX
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      oo.default_sheet = oo.sheets.first
      oo.header_line = nil
      rec = oo.find 16
      assert rec
      # keine Headerlines in diesem Beispiel definiert
      assert_equal "einundvierzig", rec[0]

      rec = oo.find 15
      assert rec
      assert_equal 41,rec[0]
    end
  end

  def test_find_by_row_google
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      oo.default_sheet = oo.sheets.first
      oo.header_line = nil
      rec = oo.find 16
      assert rec
      # keine Headerlines in diesem Beispiel definiert
      assert_equal "einundvierzig", rec[0]

      rec = oo.find 15
      assert rec
      assert_equal 41,rec[0]
    end
  end

  def test_find_by_row_huge_document_google
    if LONG_RUN
      if GOOGLE
        Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
          oo = Google.new(key_of("Bibelbund"))
          oo.default_sheet = oo.sheets.first
          rec = oo.find 20
          assert rec
          assert_equal "Brief aus dem Sekretariat", rec[0]

          rec = oo.find 22
          assert rec
          assert_equal "Brief aus dem Skretariat. Tagung in Amberg/Opf.",rec[0]
        end
      end
    end
  end

  def test_find_by_conditions_openoffice
    if LONG_RUN
      if OPENOFFICE
        assert_nothing_raised(Timeout::Error) {
          Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
            oo = Openoffice.new(File.join("test","Bibelbund.ods"))
            oo.default_sheet = oo.sheets.first
            #-----------------------------------------------------------------
            zeilen = oo.find(:all, :conditions => {
                'TITEL' => 'Brief aus dem Sekretariat'
              }
            )
            assert_equal 2, zeilen.size
            assert_equal [{"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>316.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1982-3.pdf#",
                "NUMMER"=>"1982-3",
                "TITEL"=>"Brief aus dem Sekretariat"},
              {"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>222.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1983-2.pdf#",
                "NUMMER"=>"1983-2",
                "TITEL"=>"Brief aus dem Sekretariat"}] , zeilen

            #----------------------------------------------------------
            zeilen = oo.find(:all,
              :conditions => { 'VERFASSER' => 'Almassy, Annelene von' }
            )
            assert_equal 13, zeilen.size
            #----------------------------------------------------------
            zeilen = oo.find(:all, :conditions => {
                'TITEL' => 'Brief aus dem Sekretariat',
                'VERFASSER' => 'Almassy, Annelene von',
              }
            )
            assert_equal 2, zeilen.size
            assert_equal [{"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>316.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1982-3.pdf#",
                "NUMMER"=>"1982-3",
                "TITEL"=>"Brief aus dem Sekretariat"},
              {"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>222.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1983-2.pdf#",
                "NUMMER"=>"1983-2",
                "TITEL"=>"Brief aus dem Sekretariat"}] , zeilen

            # Result as an array
            zeilen = oo.find(:all,
              :conditions => {
                'TITEL' => 'Brief aus dem Sekretariat',
                'VERFASSER' => 'Almassy, Annelene von',
              }, :array => true)
            assert_equal 2, zeilen.size
            assert_equal [
              [
                "Brief aus dem Sekretariat",
                "Almassy, Annelene von",
                "Bibel+Gem",
                "1982-3",
                316.0,
                nil,
                "#C:\\Bibelbund\\reprint\\BuG1982-3.pdf#",
                "Aus dem Bibelbund",
              ],
              [
                "Brief aus dem Sekretariat",
                "Almassy, Annelene von",
                "Bibel+Gem",
                "1983-2",
                222.0,
                nil,
                "#C:\\Bibelbund\\reprint\\BuG1983-2.pdf#",
                "Aus dem Bibelbund",
              ]] , zeilen
          end # Timeout
        } # nothing_raised
      end
    end
  end

  def test_find_by_conditions_excel
    if LONG_RUN
      if EXCEL
        assert_nothing_raised(Timeout::Error) {
          Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
            oo = Excel.new(File.join("test","Bibelbund.xls"))
            oo.default_sheet = oo.sheets.first
            #-----------------------------------------------------------------
            zeilen = oo.find(:all, :conditions => {
                'TITEL' => 'Brief aus dem Sekretariat'
              }
            )
            assert_equal 2, zeilen.size
            assert_equal [{"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>316.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1982-3.pdf#",
                "NUMMER"=>"1982-3",
                "TITEL"=>"Brief aus dem Sekretariat"},
              {"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>222.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1983-2.pdf#",
                "NUMMER"=>"1983-2",
                "TITEL"=>"Brief aus dem Sekretariat"}] , zeilen

            #----------------------------------------------------------
            zeilen = oo.find(:all,
              :conditions => { 'VERFASSER' => 'Almassy, Annelene von' }
            )
            assert_equal 13, zeilen.size
            #----------------------------------------------------------
            zeilen = oo.find(:all, :conditions => {
                'TITEL' => 'Brief aus dem Sekretariat',
                'VERFASSER' => 'Almassy, Annelene von',
              }
            )
            assert_equal 2, zeilen.size
            assert_equal [{"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>316.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1982-3.pdf#",
                "NUMMER"=>"1982-3",
                "TITEL"=>"Brief aus dem Sekretariat"},
              {"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>222.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1983-2.pdf#",
                "NUMMER"=>"1983-2",
                "TITEL"=>"Brief aus dem Sekretariat"}] , zeilen
          end # Timeout
        } # nothing_raised
      end
    end
  end

  def test_find_by_conditions_excelx
    if LONG_RUN
      if EXCELX
        assert_nothing_raised(Timeout::Error) {
          Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
            oo = Excelx.new(File.join("test","Bibelbund.xlsx"))
            oo.default_sheet = oo.sheets.first
            #-----------------------------------------------------------------
            zeilen = oo.find(:all, :conditions => {
                'TITEL' => 'Brief aus dem Sekretariat'
              }
            )
            assert_equal 2, zeilen.size
            assert_equal [{"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>316.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1982-3.pdf#",
                "NUMMER"=>"1982-3",
                "TITEL"=>"Brief aus dem Sekretariat"},
              {"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>222.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1983-2.pdf#",
                "NUMMER"=>"1983-2",
                "TITEL"=>"Brief aus dem Sekretariat"}] , zeilen

            #----------------------------------------------------------
            zeilen = oo.find(:all,
              :conditions => { 'VERFASSER' => 'Almassy, Annelene von' }
            )
            assert_equal 13, zeilen.size
            #----------------------------------------------------------
            zeilen = oo.find(:all, :conditions => {
                'TITEL' => 'Brief aus dem Sekretariat',
                'VERFASSER' => 'Almassy, Annelene von',
              }
            )
            assert_equal 2, zeilen.size
            assert_equal [{"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>316.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1982-3.pdf#",
                "NUMMER"=>"1982-3",
                "TITEL"=>"Brief aus dem Sekretariat"},
              {"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>222.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1983-2.pdf#",
                "NUMMER"=>"1983-2",
                "TITEL"=>"Brief aus dem Sekretariat"}] , zeilen
          end # Timeout
        } # nothing_raised
      end
    end
  end

  def test_find_by_conditions_google
    if LONG_RUN
      if GOOGLE
        assert_nothing_raised(Timeout::Error) {
          Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
            oo = Google.new(key_of("Bibelbund"))
            oo.default_sheet = oo.sheets.first
            #-----------------------------------------------------------------
            zeilen = oo.find(:all, :conditions => {
                'TITEL' => 'Brief aus dem Sekretariat'
              }
            )
            assert_equal 2, zeilen.size
            assert_equal [{"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>316.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1982-3.pdf#",
                "NUMMER"=>"1982-3",
                "TITEL"=>"Brief aus dem Sekretariat"},
              {"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>222.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1983-2.pdf#",
                "NUMMER"=>"1983-2",
                "TITEL"=>"Brief aus dem Sekretariat"}] , zeilen

            #----------------------------------------------------------
            zeilen = oo.find(:all,
              :conditions => { 'VERFASSER' => 'Almassy, Annelene von' }
            )
            assert_equal 13, zeilen.size
            #----------------------------------------------------------
            zeilen = oo.find(:all, :conditions => {
                'TITEL' => 'Brief aus dem Sekretariat',
                'VERFASSER' => 'Almassy, Annelene von',
              }
            )
            assert_equal 2, zeilen.size
            assert_equal [{"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>316.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1982-3.pdf#",
                "NUMMER"=>"1982-3",
                "TITEL"=>"Brief aus dem Sekretariat"},
              {"VERFASSER"=>"Almassy, Annelene von",
                "INTERNET"=>nil,
                "SEITE"=>222.0,
                "KENNUNG"=>"Aus dem Bibelbund",
                "OBJEKT"=>"Bibel+Gem",
                "PC"=>"#C:\\Bibelbund\\reprint\\BuG1983-2.pdf#",
                "NUMMER"=>"1983-2",
                "TITEL"=>"Brief aus dem Sekretariat"}] , zeilen

            # Result as an array
            zeilen = oo.find(:all,
              :conditions => {
                'TITEL' => 'Brief aus dem Sekretariat',
                'VERFASSER' => 'Almassy, Annelene von',
              }, :array => true)
            assert_equal 2, zeilen.size
            assert_equal [
              [
                "Brief aus dem Sekretariat",
                "Almassy, Annelene von",
                "Bibel+Gem",
                "1982-3",
                316.0,
                nil,
                "#C:\\Bibelbund\\reprint\\BuG1982-3.pdf#",
                "Aus dem Bibelbund",
              ],
              [
                "Brief aus dem Sekretariat",
                "Almassy, Annelene von",
                "Bibel+Gem",
                "1983-2",
                222.0,
                nil,
                "#C:\\Bibelbund\\reprint\\BuG1983-2.pdf#",
                "Aus dem Bibelbund",
              ]] , zeilen
          end # Timeout
        } # nothing_raised
      end
    end
  end

  def test_column_openoffice
    expected = [1.0,5.0,nil,10.0,Date.new(1961,11,21),'tata',nil,nil,nil,nil,'thisisa11',41.0,nil,nil,41.0,'einundvierzig',nil,Date.new(2007,5,31)]
    if OPENOFFICE
      Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
        oo = Openoffice.new(File.join('test','numbers1.ods'))
        oo.default_sheet = oo.sheets.first
        assert_equal expected, oo.column(1)
        assert_equal expected, oo.column('a')
      end
    end
  end

  def test_column_excel
    expected = [1.0,5.0,nil,10.0,Date.new(1961,11,21),'tata',nil,nil,nil,nil,'thisisa11',41.0,nil,nil,41.0,'einundvierzig',nil,Date.new(2007,5,31)]
    if EXCEL
      Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
        oo = Excel.new(File.join('test','numbers1.xls'))
        oo.default_sheet = oo.sheets.first
        assert_equal expected, oo.column(1)
        assert_equal expected, oo.column('a')
      end
    end
  end

  def test_column_excelx
    expected = [1.0,5.0,nil,10.0,Date.new(1961,11,21),'tata',nil,nil,nil,nil,'thisisa11',41.0,nil,nil,41.0,'einundvierzig',nil,Date.new(2007,5,31)]
    if EXCELX
      Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
        oo = Excelx.new(File.join('test','numbers1.xlsx'))
        oo.default_sheet = oo.sheets.first
        assert_equal expected, oo.column(1)
        assert_equal expected, oo.column('a')
      end
    end
  end

  def test_column_google
    expected = [1.0,5.0,nil,10.0,Date.new(1961,11,21),'tata',nil,nil,nil,nil,'thisisa11',41.0,nil,nil,41.0,'einundvierzig',nil,Date.new(2007,5,31)]
    if GOOGLE
      Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
        oo = Google.new(key_of('numbers1'))
        oo.default_sheet = oo.sheets.first
        assert_equal expected, oo.column(1)
        assert_equal expected, oo.column('a')
      end
    end
  end

  def test_column_huge_document_openoffice
    if LONG_RUN
      if OPENOFFICE
        assert_nothing_raised(Timeout::Error) {
          Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
            oo = Openoffice.new(File.join('test','Bibelbund.ods'))
            oo.default_sheet = oo.sheets.first
            assert_equal 3735, oo.column('a').size
            #assert_equal 499, oo.column('a').size
          end
        }
      end
    end
  end

  def test_column_huge_document_excel
    if LONG_RUN
      if EXCEL
        assert_nothing_raised(Timeout::Error) {
          Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
            oo = Excel.new(File.join('test','Bibelbund.xls'))
            oo.default_sheet = oo.sheets.first
            assert_equal 3735, oo.column('a').size
            #assert_equal 499, oo.column('a').size
          end
        }
      end
    end
  end

  def test_column_huge_document_excelx
    if LONG_RUN
      if EXCELX
        assert_nothing_raised(Timeout::Error) {
          Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
            oo = Excelx.new(File.join('test','Bibelbund.xlsx'))
            oo.default_sheet = oo.sheets.first
            assert_equal 3735, oo.column('a').size
            #assert_equal 499, oo.column('a').size
          end
        }
      end
    end
  end

  def test_column_huge_document_google
    if LONG_RUN
      if GOOGLE
        assert_nothing_raised(Timeout::Error) {
          Timeout::timeout(GLOBAL_TIMEOUT) do |timeout_length|
            #puts Time.now.to_s + "column Openoffice gestartet"
            oo = Google.new(key_of('Bibelbund'))
            oo.default_sheet = oo.sheets.first
            #assert_equal 3735, oo.column('a').size
            assert_equal 499, oo.column('a').size
            #puts Time.now.to_s + "column Openoffice beendet"
          end
        }
      end
    end
  end

  def test_simple_spreadsheet_find_by_condition_openoffice
    oo = Openoffice.new(File.join("test","simple_spreadsheet.ods"))
    oo.default_sheet = oo.sheets.first
    oo.header_line = 3
    erg = oo.find(:all, :conditions => {'Comment' => 'Task 1'})
    assert_equal Date.new(2007,05,07), erg[1]['Date']
    assert_equal 10.75       , erg[1]['Start time']
    assert_equal 12.50       , erg[1]['End time']
    assert_equal 0           , erg[1]['Pause']
    assert_equal 1.75        , erg[1]['Sum']
    assert_equal "Task 1"    , erg[1]['Comment']
  end

  def test_simple_spreadsheet_find_by_condition_excel
if EXCEL
    oo = Excel.new(File.join("test","simple_spreadsheet.xls"))
    oo.default_sheet = oo.sheets.first
    oo.header_line = 3
    erg = oo.find(:all, :conditions => {'Comment' => 'Task 1'})
    assert_equal Date.new(2007,05,07), erg[1]['Date']
    assert_equal 10.75       , erg[1]['Start time']
    assert_equal 12.50       , erg[1]['End time']
    assert_equal 0           , erg[1]['Pause']
    #cannot be tested because excel cannot return the result of formulas:
    #                    assert_equal 1.75        , erg[1]['Sum']
    assert_equal "Task 1"    , erg[1]['Comment']
end
  end

  def test_simple_spreadsheet_find_by_condition_excelx
    if EXCELX
      after Date.new(2008,5,25) do
        oo = Excelx.new(File.join("test","simple_spreadsheet.xlsx"))
        oo.default_sheet = oo.sheets.first
        oo.header_line = 3
        erg = oo.find(:all, :conditions => {'Comment' => 'Task 1'})
        p erg
        #
        #

        # hier bekomme ich den celltype :time zurueck
        assert_equal Date.new(2007,05,07), erg[1]['Date']
        assert_equal 10.75       , erg[1]['Start time']
        assert_equal 12.50       , erg[1]['End time']
        assert_equal 0           , erg[1]['Pause']
        assert_equal 1.75        , erg[1]['Sum']
        assert_equal "Task 1"    , erg[1]['Comment']
      end
    end
  end

  def test_simple_spreadsheet_find_by_condition_google
    if GOOGLE
      oo = Google.new(key_of("simple_spreadsheet"))
      oo.default_sheet = oo.sheets.first
      oo.header_line = 3
      erg = oo.find(:all, :conditions => {'Comment' => 'Task 1'})
      assert_equal Date.new(2007,05,07), erg[1]['Date']
      assert_equal 10.75       , erg[1]['Start time']
      assert_equal 12.50       , erg[1]['End time']
      assert_equal 0           , erg[1]['Pause']
      assert_kind_of Float, erg[1]['Sum']
      assert_equal 1.75        , erg[1]['Sum']
      assert_equal "Task 1"    , erg[1]['Comment']
    end
  end

  def DONT_test_false_encoding
    ex = Excel.new(File.join('test','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_bug_false_borders_with_formulas
    after Date.new(2008,5,30) do     
      #TODO: fehlt in Manifest
      ex = Excel.new(File.join('test','false_encoding.xls'))
      ex.default_sheet = ex.sheets.first
      assert_equal 1, ex.first_row
      assert_equal 3, ex.last_row
      assert_equal 1, ex.first_column
      assert_equal 4, ex.last_column
    end
  end

  def test_fe
    after Date.new(2008,5,30) do
      ex = Excel.new(File.join('test','false_encoding.xls'))
      ex.default_sheet = ex.sheets.first
      #DOES NOT WORK IN EXCEL FILES: assert_equal Date.new(2007,11,1), ex.cell('a',1)
      #DOES NOT WORK IN EXCEL FILES: assert_equal true, ex.formula?('a',1)
      #DOES NOT WORK IN EXCEL FILES: assert_equal '=TODAY()', ex.formula('a',1)

      #DOES NOT WORK IN EXCEL FILES: assert_equal Date.new(2008,2,9), ex.cell('B',1)
      #DOES NOT WORK IN EXCEL FILES: assert_equal true,               ex.formula?('B',1)
      #DOES NOT WORK IN EXCEL FILES: assert_equal "=A1+100",          ex.formula('B',1)

      #DOES NOT WORK IN EXCEL FILES: assert_equal Date.new(2008,2,9), ex.cell('C',1)
      #DOES NOT WORK IN EXCEL FILES: assert_equal true,               ex.formula?('C',1)
      #DOES NOT WORK IN EXCEL FILES: assert_equal "=C1",          ex.formula('C',1)

      assert_equal 'H1', ex.cell('A',2)
      assert_equal 'H2', ex.cell('B',2)
      assert_equal 'H3', ex.cell('C',2)
      assert_equal 'H4', ex.cell('D',2)
      assert_equal 'R1', ex.cell('A',3)
      assert_equal 'R2', ex.cell('B',3)
      assert_equal 'R3', ex.cell('C',3)
      assert_equal 'R4', ex.cell('D',3)
    end
  end

  def test_excel_does_not_support_formulas
    if EXCEL
      ex = Excel.new(File.join('test','false_encoding.xls'))
      ex.default_sheet = ex.sheets.first
      assert_raise(RuntimeError) {
        void = ex.formula('a',1)
      }
      assert_raise(RuntimeError) {
        void = ex.formula?('a',1)
      }
      assert_raise(RuntimeError) {
        void = ex.formulas(ex.sheets.first)
      }
    end
  end

  def test_info
    expected_templ = "File: numbers1%s\n"+
      "Number of sheets: 5\n"+
      "Sheets: Tabelle1, Name of Sheet 2, Sheet3, Sheet4, Sheet5\n"+
      "Sheet 1:\n"+
      "  First row: 1\n"+
      "  Last row: 18\n"+
      "  First column: A\n"+
      "  Last column: G\n"+
      "Sheet 2:\n"+
      "  First row: 5\n"+
      "  Last row: 14\n"+
      "  First column: B\n"+
      "  Last column: E\n"+
      "Sheet 3:\n"+
      "  First row: 1\n"+
      "  Last row: 1\n"+
      "  First column: A\n"+
      "  Last column: BA\n"+
      "Sheet 4:\n"+
      "  First row: 1\n"+
      "  Last row: 1\n"+
      "  First column: A\n"+
      "  Last column: E\n"+
      "Sheet 5:\n"+
      "  First row: 1\n"+
      "  Last row: 6\n"+
      "  First column: A\n"+
      "  Last column: E"
    if OPENOFFICE
      ext = ".ods"
      expected = sprintf(expected_templ,ext)
      oo = Openoffice.new(File.join("test","numbers1.ods"))
      assert_equal expected, oo.info
    end
    if EXCEL
      ext = ".xls"
      expected = sprintf(expected_templ,ext)
      oo = Excel.new(File.join("test","numbers1.xls"))
      assert_equal expected, oo.info
    end
    if EXCELX
      ext = ".xlsx"
      expected = sprintf(expected_templ,ext)
      oo = Excelx.new(File.join("test","numbers1.xlsx"))
      assert_equal expected, oo.info
    end
    if GOOGLE
      ext = ""
      expected = sprintf(expected_templ,ext)
      oo = Google.new(key_of("numbers1"))
      #$log.debug(expected)
      assert_equal expected.gsub(/numbers1/,key_of("numbers1")), oo.info
    end
  end

  def test_bug_excel_numbers1_sheet5_last_row
    oo = Excel.new(File.join("test","numbers1.xls"))
    oo.default_sheet = "Tabelle1"
    assert_equal 1, oo.first_row
    assert_equal 18, oo.last_row
    assert_equal Openoffice.letter_to_number('A'), oo.first_column
    assert_equal Openoffice.letter_to_number('G'), oo.last_column
    oo.default_sheet = "Name of Sheet 2"
    assert_equal 5, oo.first_row
    assert_equal 14, oo.last_row
    assert_equal Openoffice.letter_to_number('B'), oo.first_column
    assert_equal Openoffice.letter_to_number('E'), oo.last_column
    oo.default_sheet = "Sheet3"
    assert_equal 1, oo.first_row
    assert_equal 1, oo.last_row
    assert_equal Openoffice.letter_to_number('A'), oo.first_column
    assert_equal Openoffice.letter_to_number('BA'), oo.last_column
    oo.default_sheet = "Sheet4"
    assert_equal 1, oo.first_row
    assert_equal 1, oo.last_row
    assert_equal Openoffice.letter_to_number('A'), oo.first_column
    assert_equal Openoffice.letter_to_number('E'), oo.last_column
    oo.default_sheet = "Sheet5"
    assert_equal 1, oo.first_row
    assert_equal 6, oo.last_row
    assert_equal Openoffice.letter_to_number('A'), oo.first_column
    assert_equal Openoffice.letter_to_number('E'), oo.last_column
  end

  def test_should_raise_file_not_found_error
    if OPENOFFICE
      assert_raise(IOError) {
        oo = Openoffice.new(File.join('testnichtvorhanden','Bibelbund.ods'))
      }
    end
    if EXCEL
      assert_raise(IOError) {
        oo = Excel.new(File.join('testnichtvorhanden','Bibelbund.xls'))
      }
    end
    if EXCELX
      assert_raise(IOError) {
        oo = Excelx.new(File.join('testnichtvorhanden','Bibelbund.xlsx'))
      }
    end
    if GOOGLE
      assert_raise(IOError) {
        # oo = Google.new(key_of('testnichtvorhanden'+'Bibelbund.ods'))
        oo = Google.new('testnichtvorhanden')
      }
    end
  end

  def test_bug_cell_no_default_sheet
    if GOOGLE
      oo = Google.new(key_of("numbers1"))
      assert_raise(ArgumentError) {
        # should complain about not set default-sheet
        #assert_equal 1.0, oo.cell('A',1)
        value = oo.cell('A',1)
        assert_equal "ganz rechts  gehts noch wetier", oo.cell('A',1,"Sheet3")
      }
    end
  end

  def test_write_google
    # write.me: http://spreadsheets.google.com/ccc?key=ptu6bbahNZpY0N0RrxQbWdw&hl=en_GB
    if GOOGLE
      oo = Google.new('ptu6bbahNZpY0N0RrxQbWdw')
      oo.default_sheet = oo.sheets.first
      oo.set_value(1,1,"hello from the tests")
      #oo.set_value(1,1,"sin(1)")
      assert_equal "hello from the tests", oo.cell(1,1)
    end
  end

  def test_bug_set_value_with_more_than_one_sheet_google
    # write.me: http://spreadsheets.google.com/ccc?key=ptu6bbahNZpY0N0RrxQbWdw&hl=en_GB
    if GOOGLE
      content1 = 'AAA'
      content2 = 'BBB'
      oo = Google.new('ptu6bbahNZpY0N0RrxQbWdw')
      oo.default_sheet = oo.sheets.first
      oo.set_value(1,1,content1)
      oo.default_sheet = oo.sheets[1]
      oo.set_value(1,1,content2) # in the second sheet
      oo.default_sheet = oo.sheets.first
      assert_equal content1, oo.cell(1,1)
      oo.default_sheet = oo.sheets[1]
      assert_equal content2, oo.cell(1,1)
    end
  end

  def test_set_value_with_sheet_argument_google
    if GOOGLE
      random_row = rand(10)+1
      random_column = rand(10)+1
      oo = Google.new('ptu6bbahNZpY0N0RrxQbWdw')
      oo.default_sheet = oo.sheets.first
      content1 = 'ABC'
      content2 = 'DEF'
      oo.set_value(random_row,random_column,content1,oo.sheets.first)
      oo.set_value(random_row,random_column,content2,oo.sheets[1])
      assert_equal content1, oo.cell(random_row,random_column,oo.sheets.first)
      assert_equal content2, oo.cell(random_row,random_column,oo.sheets[1])
    end
  end

  def test_set_value_for_non_existing_sheet_google
    if GOOGLE
      oo = Google.new('ptu6bbahNZpY0N0RrxQbWdw')
      assert_raise(RangeError) {
        #oo.default_sheet = "no_sheet"
        oo.set_value(1,1,"dummy","no_sheet")
      }
    end # GOOGLE
  end

  def test_bug_bbu_openoffice
    oo = Openoffice.new(File.join('test','bbu.ods'))
    assert_nothing_raised() {
      assert_equal "File: bbu.ods
Number of sheets: 3
Sheets: 2007_12, Tabelle2, Tabelle3
Sheet 1:
  First row: 1
  Last row: 4
  First column: A
  Last column: F
Sheet 2:
  - empty -
Sheet 3:
  - empty -", oo.info
    }

    oo.default_sheet = oo.sheets[1] # empty sheet
    assert_nil oo.first_row
    assert_nil oo.last_row
    assert_nil oo.first_column
    assert_nil oo.last_column
  end

  def test_bug_bbu_excel
    oo = Excel.new(File.join('test','bbu.xls'))
    assert_nothing_raised() {
      assert_equal "File: bbu.xls
Number of sheets: 3
Sheets: 2007_12, Tabelle2, Tabelle3
Sheet 1:
  First row: 1
  Last row: 4
  First column: A
  Last column: F
Sheet 2:
  - empty -
Sheet 3:
  - empty -", oo.info
    }

    oo.default_sheet = oo.sheets[1] # empty sheet
    assert_nil oo.first_row
    assert_nil oo.last_row
    assert_nil oo.first_column
    assert_nil oo.last_column
  end

  def test_bug_bbu_excelx
    if EXCELX
      oo = Excelx.new(File.join('test','bbu.xlsx'))
      assert_nothing_raised() {
        assert_equal "File: bbu.xlsx
Number of sheets: 3
Sheets: 2007_12, Tabelle2, Tabelle3
Sheet 1:
  First row: 1
  Last row: 4
  First column: A
  Last column: F
Sheet 2:
  - empty -
Sheet 3:
  - empty -", oo.info
      }

      oo.default_sheet = oo.sheets[1] # empty sheet
      assert_nil oo.first_row
      assert_nil oo.last_row
      assert_nil oo.first_column
      assert_nil oo.last_column
    end
  end

  if false
    # there is no google spreadsheet for this test
    def test_bug_bbu_google
      oo = Excel.new(key_of('bbu'))
      assert_nothing_raised() {
        assert_equal "File: test/bbu.xls
Number of sheets: 3
Sheets: 2007_12, Tabelle2, Tabelle3
Sheet 1:
  First row: 1
  Last row: 4
  First column: A
  Last column: F
Sheet 2:
  - empty -
Sheet 3:
  - empty -", oo.info
      }

      oo.default_sheet = oo.sheets[1] # empty sheet
      assert_nil oo.first_row
      assert_nil oo.last_row
      assert_nil oo.first_column
      assert_nil oo.last_column
    end
  end # false

  #  def teardown
  #    puts "Options:"
  #    puts "OPENOFFICE = #{OPENOFFICE}"
  #    puts "EXCEL      = #{EXCEL}"
  #    puts "GOOGLE     = #{GOOGLE}"
  #  end

  def test_bug_time_nil_openoffice
    if OPENOFFICE
      oo = Openoffice.new(File.join("test","time-test.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal 12*3600+13*60+14, oo.cell('B',1) # 12:13:14 (secs since midnight)
      assert_equal :time, oo.celltype('B',1)
      assert_equal 15*3600+16*60, oo.cell('C',1) # 15:16    (secs since midnight)
      assert_equal :time, oo.celltype('C',1)

      assert_equal 23*3600, oo.cell('D',1) # 23:00    (secs since midnight)
      assert_equal :time, oo.celltype('D',1)
    end
  end

  def test_bug_time_nil_excel
    if EXCEL
      oo = Excel.new(File.join("test","time-test.xls"))
      oo.default_sheet = oo.sheets.first
      assert_equal 12*3600+13*60+14, oo.cell('B',1) # 12:13:14 (secs since midnight)
      assert_equal :time, oo.celltype('B',1)
      assert_equal 15*3600+16*60, oo.cell('C',1) # 15:16    (secs since midnight)
      assert_equal :time, oo.celltype('C',1)

      assert_equal 23*3600, oo.cell('D',1) # 23:00    (secs since midnight)
      assert_equal :time, oo.celltype('D',1)
    end
  end

  def test_bug_time_nil_excelx
    if EXCELX
      oo = Excelx.new(File.join("test","time-test.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal 12*3600+13*60+14, oo.cell('B',1) # 12:13:14 (secs since midnight)
      assert_equal :time, oo.celltype('B',1)
      assert_equal 15*3600+16*60, oo.cell('C',1) # 15:16    (secs since midnight)
      assert_equal :time, oo.celltype('C',1)

      assert_equal 23*3600, oo.cell('D',1) # 23:00    (secs since midnight)
      assert_equal :time, oo.celltype('D',1)
    end
  end

  def test_bug_time_nil_google
    if GOOGLE
      oo = Google.new(key_of("time-test"))
      oo.default_sheet = oo.sheets.first
      assert_equal 12*3600+13*60+14, oo.cell('B',1) # 12:13:14 (secs since midnight)
      assert_equal :time, oo.celltype('B',1)
      assert_equal 15*3600+16*60, oo.cell('C',1) # 15:16    (secs since midnight)
      assert_equal :time, oo.celltype('C',1)

      assert_equal 23*3600, oo.cell('D',1) # 23:00    (secs since midnight)
      assert_equal :time, oo.celltype('D',1)
    end
  end

  def test_date_time_to_csv_openoffice
    if OPENOFFICE
      File.delete_if_exist("/tmp/time-test.csv")
      oo = Openoffice.new(File.join("test","time-test.ods"))
      oo.default_sheet = oo.sheets.first
      assert oo.to_csv("/tmp/time-test.csv")
      assert File.exists?("/tmp/time-test.csv")
      assert_equal "", `diff test/time-test.csv /tmp/time-test.csv`
    end # OPENOFFICE
  end

  def test_date_time_to_csv_excel
    if EXCEL
      after Date.new(2008,5,30) do
        #ueberfluessige leere Zeilen werden am Ende noch angehaengt
        # last_row fehlerhaft?
        File.delete_if_exist("/tmp/time-test.csv")
        oo = Excel.new(File.join("test","time-test.xls"))
        oo.default_sheet = oo.sheets.first
        assert oo.to_csv("/tmp/time-test.csv")
        assert File.exists?("/tmp/time-test.csv")
        assert_equal "", `diff test/time-test.csv /tmp/time-test.csv`
      end
    end # EXCEL
  end

  def test_date_time_to_csv_excelx
    if EXCELX
      after Date.new(2008,5,3) do
        #ueberfluessige leere Zeilen werden am Ende noch angehaengt
        # last_row fehlerhaft?
        File.delete_if_exist("/tmp/time-test.csv")
        oo = Excelx.new(File.join("test","time-test.xlsx"))
        oo.default_sheet = oo.sheets.first
        assert oo.to_csv("/tmp/time-test.csv")
        assert File.exists?("/tmp/time-test.csv")
        assert_equal "", `diff test/time-test.csv /tmp/time-test.csv`
      end
    end # EXCELX
  end

  def test_date_time_to_csv_google
    if GOOGLE
      File.delete_if_exist("/tmp/time-test.csv")
      oo = Google.new(key_of("time-test"))
      oo.default_sheet = oo.sheets.first
      assert oo.to_csv("/tmp/time-test.csv")
      assert File.exists?("/tmp/time-test.csv")
      assert_equal "", `diff test/time-test.csv /tmp/time-test.csv`
    end # GOOGLE
  end
  
  def test_date_time_yaml_openoffice
    if OPENOFFICE
      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"
      oo = Openoffice.new(File.join("test","time-test.ods"))
      oo.default_sheet = oo.sheets.first
      assert_equal expected, oo.to_yaml
    end  
  end

  def test_date_time_yaml_excel
    if EXCEL
      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"
      oo = Excel.new(File.join("test","time-test.xls"))
      oo.default_sheet = oo.sheets.first
      assert_equal expected, oo.to_yaml
    end  
  end

  def test_date_time_yaml_excelx
    if EXCELX
      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"
      oo = Excelx.new(File.join("test","time-test.xlsx"))
      oo.default_sheet = oo.sheets.first
      assert_equal expected, oo.to_yaml
    end  
  end

  def test_date_time_yaml_google
    if GOOGLE
      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"
      oo = Google.new(key_of("time-test"))
      oo.default_sheet = oo.sheets.first
      assert_equal expected, oo.to_yaml
    end  
  end

  def test_no_remaining_tmp_files_openoffice
    if OPENOFFICE
      assert_raise(Zip::ZipError) { #TODO: besseres Fehlerkriterium bei
        oo = Openoffice.new(File.join("test","no_spreadsheet_file.txt"))
      }
      a=Dir.glob("oo_*")
      assert_equal [], a
    end    
  end
  
  def test_no_remaining_tmp_files_excel
    if EXCEL
      assert_raise(OLE::UnknownFormatError) {
        oo = Excel.new(File.join("test","no_spreadsheet_file.txt"))
      }
      a=Dir.glob("oo_*")
      assert_equal [], a  
    end
  end

  def test_no_remaining_tmp_files_excelx
    if EXCELX
      assert_raise(Zip::ZipError) { #TODO: besseres Fehlerkriterium bei

        oo = Excelx.new(File.join("test","no_spreadsheet_file.txt"))
        
      }
      a=Dir.glob("oo_*")
      assert_equal [], a  
    end
  end
  
  def test_no_remaining_tmp_files_google
    if GOOGLE
      assert_nothing_raised() {
        oo = Google.new(key_of("no_spreadsheet_file.txt"))
      }
      a=Dir.glob("oo_*")
      assert_equal [], a  
    end
  end
  
  def emit_cell(row,col,type,value)
    "  <cell "+
      "type=\"#{type}\" "+
      "row=\"#{row}\" "+
      "column=\"#{col}\""+
      ">#{value}</cell>\n"
  end
    
  def test_to_xml_openoffice
    after Date.new(2008,6,1) do
      if OPENOFFICE
        oo = Openoffice.new(File.join('test','numbers1.ods'))
        expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"+
          "<sheet name=\"Tabelle1\">\n"+
          emit_cell(1,1,"float","1.0")+
          emit_cell(1,2,'float','2.0')+
          emit_cell(1,3,'float','3.0')+
          emit_cell(1,4,'float','4.0')+
          emit_cell(1,5,'formula','10.0')+
          emit_cell(2,1,'float','5.0')+
          emit_cell(2,2,'float','6.0')+
          emit_cell(2,3,'float','7.0')+
          emit_cell(2,4,'float','8.0')+
          emit_cell(2,5,'float','9.0')+
          emit_cell(2,6,'string','test')+
          emit_cell(2,7,'float','11.0')+
          emit_cell(4, 1, "float", "10.0")+
          emit_cell(4, 2, "float", "11.0")+
          emit_cell(4, 3, "float", "12.0")+
          emit_cell(4, 4, "float", "13.0")+
          emit_cell(4, 5, "float", "14.0")+
          emit_cell(5, 1, "date", "1961-11-21")+
          emit_cell(6, 1, "string", "tata")+
          emit_cell(8, 3, "string", "thisisc8")+
          emit_cell(9,4, "string", "thisisd9")+
          emit_cell(11, 1, "string", "thisisa11")+
          emit_cell(12, 1, "float", "41.0")+
          emit_cell(12, 2, "float", "42.0")+
          emit_cell(12, 3, "float", "43.0")+
          emit_cell(12, 4, "float", "44.0")+
          emit_cell(12, 5, "float", "45.0")+
          emit_cell(15, 1, "float", "41.0")+
          emit_cell(15, 2, "float", "42.0")+
          emit_cell(15, 3, "float", "43.0")+
          emit_cell(15, 4, "float", "44.0")+
          emit_cell(15, 5, "float", "45.0")+
          emit_cell(16, 1, "string", "einundvierzig")+
          emit_cell(16, 2, "string", "zweiundvierzig")+
          emit_cell(16, 3, "string", "dreiundvierzig")+
          emit_cell(16, 4, "string", "vierundvierzig")+
          emit_cell(16, 5, "string", "fuenfundvierzig")+
          emit_cell(18, 1, "date", "2007-05-31")+
          emit_cell(18, 2, "string", "dies hier als Date-Objekt")+
          "</sheet>\n"+
          "<sheet name=\"Name of Sheet 2\">\n"+
          emit_cell(5, 3, "string", "I am sheet 2")+
          emit_cell(7, 2, "float", "3.0")+
          emit_cell(10, 5, "float", "7.0")+
          emit_cell(14, 4, "float", "9.0")+
          "</sheet>\n"+
          "<sheet name=\"Sheet3\">\n"+
          emit_cell(1, 1, "string", "ganz weit rechts geht&#8217;s weiter")+
          emit_cell(1, GenericSpreadsheet.letter_to_number('AA'), "string", "i am AA")+
          emit_cell(1, GenericSpreadsheet.letter_to_number('AB'), "string", "i am AB")+
          emit_cell(1, GenericSpreadsheet.letter_to_number('BA'), "string", "i am BA")+
          "</sheet>\n"+
          "<sheet name=\"Sheet4\">\n"+
          emit_cell(1, 1, "date", "2007-06-16")+
          emit_cell(1, 2, "float", "10.0")+
          emit_cell(1, 3, "float", "10.0")+
          emit_cell(1, 4, "float", "10.0")+
          emit_cell(1, 5, "float", "10.0")+
          "</sheet>\n"+
          "<sheet name=\"Sheet5\">\n"+
          emit_cell(1, 1, "float", "1.0")+
          emit_cell(1, 2, "float", "5.0")+
          emit_cell(1, 3, "float", "5.0")+
          emit_cell(2, 1, "float", "2.0")+
          emit_cell(3, 1, "float", "3.0")+
          emit_cell(4, 1, "date", "2007-11-21")+
          emit_cell(4, 2, "date", "2007-11-21")+
          emit_cell(4, 3, "date", "2007-11-21")+
          emit_cell(4, 4, "date", "2007-11-21")+
          emit_cell(4, 5, "date", "2007-11-21")+
          emit_cell(5, 1, "float", "42.0")+
          emit_cell(5, 2, "float", "42.0")+
          emit_cell(5, 3, "float", "42.0")+
          emit_cell(5, 4, "float", "42.0")+
          emit_cell(5, 5, "float", "42.0")+
          emit_cell(6, 1, "string", "ABC")+
          emit_cell(6, 2, "string", "ABC")+
          emit_cell(6, 3, "string", "ABC")+
          emit_cell(6, 4, "string", "ABC")+
          emit_cell(6, 5, "string", "ABC")+
          "</sheet>\n"+
          ""
        #          oo.default_sheet = oo.sheets.first
        assert_equal expected, oo.to_xml
      end
    end
  end

  def test_to_xml_excel
    after Date.new(2008,6,1) do
      if EXCEL
        oo = Excel.new(File.join('test','numbers1.xls'))
        expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"+
          "<sheet name=\"Tabelle1\">\n"+
          emit_cell(1,1,"float","1.0")+
          emit_cell(1,2,'float','2.0')+
          emit_cell(1,3,'float','3.0')+
          emit_cell(1,4,'float','4.0')+
          emit_cell(1,5,'formula','10.0')+
          emit_cell(2,1,'float','5.0')+
          emit_cell(2,2,'float','6.0')+
          emit_cell(2,3,'float','7.0')+
          emit_cell(2,4,'float','8.0')+
          emit_cell(2,5,'float','9.0')+
          emit_cell(2,6,'string','test')+
          emit_cell(2,7,'float','11.0')+
          emit_cell(4, 1, "float", "10.0")+
          emit_cell(4, 2, "float", "11.0")+
          emit_cell(4, 3, "float", "12.0")+
          emit_cell(4, 4, "float", "13.0")+
          emit_cell(4, 5, "float", "14.0")+
          emit_cell(5, 1, "date", "1961-11-21")+
          emit_cell(6, 1, "string", "tata")+
          emit_cell(8, 3, "string", "thisisc8")+
          emit_cell(9,4, "string", "thisisd9")+
          emit_cell(11, 1, "string", "thisisa11")+
          emit_cell(12, 1, "float", "41.0")+
          emit_cell(12, 2, "float", "42.0")+
          emit_cell(12, 3, "float", "43.0")+
          emit_cell(12, 4, "float", "44.0")+
          emit_cell(12, 5, "float", "45.0")+
          emit_cell(15, 1, "float", "41.0")+
          emit_cell(15, 2, "float", "42.0")+
          emit_cell(15, 3, "float", "43.0")+
          emit_cell(15, 4, "float", "44.0")+
          emit_cell(15, 5, "float", "45.0")+
          emit_cell(16, 1, "string", "einundvierzig")+
          emit_cell(16, 2, "string", "zweiundvierzig")+
          emit_cell(16, 3, "string", "dreiundvierzig")+
          emit_cell(16, 4, "string", "vierundvierzig")+
          emit_cell(16, 5, "string", "fuenfundvierzig")+
          emit_cell(18, 1, "date", "2007-05-31")+
          emit_cell(18, 2, "string", "dies hier als Date-Objekt")+
          "</sheet>\n"+
          "<sheet name=\"Name of Sheet 2\">\n"+
          emit_cell(5, 3, "string", "I am sheet 2")+
          emit_cell(7, 2, "float", "3.0")+
          emit_cell(10, 5, "float", "7.0")+
          emit_cell(14, 4, "float", "9.0")+
          "</sheet>\n"+
          "<sheet name=\"Sheet3\">\n"+
          emit_cell(1, 1, "string", "ganz weit rechts geht&#8217;s weiter")+
          emit_cell(1, GenericSpreadsheet.letter_to_number('AA'), "string", "i am AA")+
          emit_cell(1, GenericSpreadsheet.letter_to_number('AB'), "string", "i am AB")+
          emit_cell(1, GenericSpreadsheet.letter_to_number('BA'), "string", "i am BA")+
          "</sheet>\n"+
          "<sheet name=\"Sheet4\">\n"+
          emit_cell(1, 1, "date", "2007-06-16")+
          emit_cell(1, 2, "float", "10.0")+
          emit_cell(1, 3, "float", "10.0")+
          emit_cell(1, 4, "float", "10.0")+
          emit_cell(1, 5, "float", "10.0")+
          "</sheet>\n"+
          "<sheet name=\"Sheet5\">\n"+
          emit_cell(1, 1, "float", "1.0")+
          emit_cell(1, 2, "float", "5.0")+
          emit_cell(1, 3, "float", "5.0")+
          emit_cell(2, 1, "float", "2.0")+
          emit_cell(3, 1, "float", "3.0")+
          emit_cell(4, 1, "date", "2007-11-21")+
          emit_cell(4, 2, "date", "2007-11-21")+
          emit_cell(4, 3, "date", "2007-11-21")+
          emit_cell(4, 4, "date", "2007-11-21")+
          emit_cell(4, 5, "date", "2007-11-21")+
          emit_cell(5, 1, "float", "42.0")+
          emit_cell(5, 2, "float", "42.0")+
          emit_cell(5, 3, "float", "42.0")+
          emit_cell(5, 4, "float", "42.0")+
          emit_cell(5, 5, "float", "42.0")+
          emit_cell(6, 1, "string", "ABC")+
          emit_cell(6, 2, "string", "ABC")+
          emit_cell(6, 3, "string", "ABC")+
          emit_cell(6, 4, "string", "ABC")+
          emit_cell(6, 5, "string", "ABC")+
          "</sheet>\n"+
          ""
        #          oo.default_sheet = oo.sheets.first
        assert_equal expected, oo.to_xml
      end
    end
  end

  def test_to_xml_excelx
    after Date.new(2008,6,1) do
      if EXCELX
        oo = Excelx.new(File.join('test','numbers1.xlsx'))
        expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"+
          "<sheet name=\"Tabelle1\">\n"+
          emit_cell(1,1,"float","1.0")+
          emit_cell(1,2,'float','2.0')+
          emit_cell(1,3,'float','3.0')+
          emit_cell(1,4,'float','4.0')+
          emit_cell(1,5,'formula','10.0')+
          emit_cell(2,1,'float','5.0')+
          emit_cell(2,2,'float','6.0')+
          emit_cell(2,3,'float','7.0')+
          emit_cell(2,4,'float','8.0')+
          emit_cell(2,5,'float','9.0')+
          emit_cell(2,6,'string','test')+
          emit_cell(2,7,'float','11.0')+
          emit_cell(4, 1, "float", "10.0")+
          emit_cell(4, 2, "float", "11.0")+
          emit_cell(4, 3, "float", "12.0")+
          emit_cell(4, 4, "float", "13.0")+
          emit_cell(4, 5, "float", "14.0")+
          emit_cell(5, 1, "date", "1961-11-21")+
          emit_cell(6, 1, "string", "tata")+
          emit_cell(8, 3, "string", "thisisc8")+
          emit_cell(9,4, "string", "thisisd9")+
          emit_cell(11, 1, "string", "thisisa11")+
          emit_cell(12, 1, "float", "41.0")+
          emit_cell(12, 2, "float", "42.0")+
          emit_cell(12, 3, "float", "43.0")+
          emit_cell(12, 4, "float", "44.0")+
          emit_cell(12, 5, "float", "45.0")+
          emit_cell(15, 1, "float", "41.0")+
          emit_cell(15, 2, "float", "42.0")+
          emit_cell(15, 3, "float", "43.0")+
          emit_cell(15, 4, "float", "44.0")+
          emit_cell(15, 5, "float", "45.0")+
          emit_cell(16, 1, "string", "einundvierzig")+
          emit_cell(16, 2, "string", "zweiundvierzig")+
          emit_cell(16, 3, "string", "dreiundvierzig")+
          emit_cell(16, 4, "string", "vierundvierzig")+
          emit_cell(16, 5, "string", "fuenfundvierzig")+
          emit_cell(18, 1, "date", "2007-05-31")+
          emit_cell(18, 2, "string", "dies hier als Date-Objekt")+
          "</sheet>\n"+
          "<sheet name=\"Name of Sheet 2\">\n"+
          emit_cell(5, 3, "string", "I am sheet 2")+
          emit_cell(7, 2, "float", "3.0")+
          emit_cell(10, 5, "float", "7.0")+
          emit_cell(14, 4, "float", "9.0")+
          "</sheet>\n"+
          "<sheet name=\"Sheet3\">\n"+
          emit_cell(1, 1, "string", "ganz weit rechts geht&#8217;s weiter")+
          emit_cell(1, GenericSpreadsheet.letter_to_number('AA'), "string", "i am AA")+
          emit_cell(1, GenericSpreadsheet.letter_to_number('AB'), "string", "i am AB")+
          emit_cell(1, GenericSpreadsheet.letter_to_number('BA'), "string", "i am BA")+
          "</sheet>\n"+
          "<sheet name=\"Sheet4\">\n"+
          emit_cell(1, 1, "date", "2007-06-16")+
          emit_cell(1, 2, "float", "10.0")+
          emit_cell(1, 3, "float", "10.0")+
          emit_cell(1, 4, "float", "10.0")+
          emit_cell(1, 5, "float", "10.0")+
          "</sheet>\n"+
          "<sheet name=\"Sheet5\">\n"+
          emit_cell(1, 1, "float", "1.0")+
          emit_cell(1, 2, "float", "5.0")+
          emit_cell(1, 3, "float", "5.0")+
          emit_cell(2, 1, "float", "2.0")+
          emit_cell(3, 1, "float", "3.0")+
          emit_cell(4, 1, "date", "2007-11-21")+
          emit_cell(4, 2, "date", "2007-11-21")+
          emit_cell(4, 3, "date", "2007-11-21")+
          emit_cell(4, 4, "date", "2007-11-21")+
          emit_cell(4, 5, "date", "2007-11-21")+
          emit_cell(5, 1, "float", "42.0")+
          emit_cell(5, 2, "float", "42.0")+
          emit_cell(5, 3, "float", "42.0")+
          emit_cell(5, 4, "float", "42.0")+
          emit_cell(5, 5, "float", "42.0")+
          emit_cell(6, 1, "string", "ABC")+
          emit_cell(6, 2, "string", "ABC")+
          emit_cell(6, 3, "string", "ABC")+
          emit_cell(6, 4, "string", "ABC")+
          emit_cell(6, 5, "string", "ABC")+
          "</sheet>\n"+
          ""
        #          oo.default_sheet = oo.sheets.first
        assert_equal expected, oo.to_xml
      end
    end
  end

  def test_to_xml_google
    after Date.new(2008,6,1) do
      if GOOGLE
        oo = Google.new(key_of(File.join('test','numbers1.xlsx')))
        expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"+
          "<sheet name=\"Tabelle1\">\n"+
          emit_cell(1,1,"float","1.0")+
          emit_cell(1,2,'float','2.0')+
          emit_cell(1,3,'float','3.0')+
          emit_cell(1,4,'float','4.0')+
          emit_cell(1,5,'formula','10.0')+
          emit_cell(2,1,'float','5.0')+
          emit_cell(2,2,'float','6.0')+
          emit_cell(2,3,'float','7.0')+
          emit_cell(2,4,'float','8.0')+
          emit_cell(2,5,'float','9.0')+
          emit_cell(2,6,'string','test')+
          emit_cell(2,7,'float','11.0')+
          emit_cell(4, 1, "float", "10.0")+
          emit_cell(4, 2, "float", "11.0")+
          emit_cell(4, 3, "float", "12.0")+
          emit_cell(4, 4, "float", "13.0")+
          emit_cell(4, 5, "float", "14.0")+
          emit_cell(5, 1, "date", "1961-11-21")+
          emit_cell(6, 1, "string", "tata")+
          emit_cell(8, 3, "string", "thisisc8")+
          emit_cell(9,4, "string", "thisisd9")+
          emit_cell(11, 1, "string", "thisisa11")+
          emit_cell(12, 1, "float", "41.0")+
          emit_cell(12, 2, "float", "42.0")+
          emit_cell(12, 3, "float", "43.0")+
          emit_cell(12, 4, "float", "44.0")+
          emit_cell(12, 5, "float", "45.0")+
          emit_cell(15, 1, "float", "41.0")+
          emit_cell(15, 2, "float", "42.0")+
          emit_cell(15, 3, "float", "43.0")+
          emit_cell(15, 4, "float", "44.0")+
          emit_cell(15, 5, "float", "45.0")+
          emit_cell(16, 1, "string", "einundvierzig")+
          emit_cell(16, 2, "string", "zweiundvierzig")+
          emit_cell(16, 3, "string", "dreiundvierzig")+
          emit_cell(16, 4, "string", "vierundvierzig")+
          emit_cell(16, 5, "string", "fuenfundvierzig")+
          emit_cell(18, 1, "date", "2007-05-31")+
          emit_cell(18, 2, "string", "dies hier als Date-Objekt")+
          "</sheet>\n"+
          "<sheet name=\"Name of Sheet 2\">\n"+
          emit_cell(5, 3, "string", "I am sheet 2")+
          emit_cell(7, 2, "float", "3.0")+
          emit_cell(10, 5, "float", "7.0")+
          emit_cell(14, 4, "float", "9.0")+
          "</sheet>\n"+
          "<sheet name=\"Sheet3\">\n"+
          emit_cell(1, 1, "string", "ganz weit rechts geht&#8217;s weiter")+
          emit_cell(1, GenericSpreadsheet.letter_to_number('AA'), "string", "i am AA")+
          emit_cell(1, GenericSpreadsheet.letter_to_number('AB'), "string", "i am AB")+
          emit_cell(1, GenericSpreadsheet.letter_to_number('BA'), "string", "i am BA")+
          "</sheet>\n"+
          "<sheet name=\"Sheet4\">\n"+
          emit_cell(1, 1, "date", "2007-06-16")+
          emit_cell(1, 2, "float", "10.0")+
          emit_cell(1, 3, "float", "10.0")+
          emit_cell(1, 4, "float", "10.0")+
          emit_cell(1, 5, "float", "10.0")+
          "</sheet>\n"+
          "<sheet name=\"Sheet5\">\n"+
          emit_cell(1, 1, "float", "1.0")+
          emit_cell(1, 2, "float", "5.0")+
          emit_cell(1, 3, "float", "5.0")+
          emit_cell(2, 1, "float", "2.0")+
          emit_cell(3, 1, "float", "3.0")+
          emit_cell(4, 1, "date", "2007-11-21")+
          emit_cell(4, 2, "date", "2007-11-21")+
          emit_cell(4, 3, "date", "2007-11-21")+
          emit_cell(4, 4, "date", "2007-11-21")+
          emit_cell(4, 5, "date", "2007-11-21")+
          emit_cell(5, 1, "float", "42.0")+
          emit_cell(5, 2, "float", "42.0")+
          emit_cell(5, 3, "float", "42.0")+
          emit_cell(5, 4, "float", "42.0")+
          emit_cell(5, 5, "float", "42.0")+
          emit_cell(6, 1, "string", "ABC")+
          emit_cell(6, 2, "string", "ABC")+
          emit_cell(6, 3, "string", "ABC")+
          emit_cell(6, 4, "string", "ABC")+
          emit_cell(6, 5, "string", "ABC")+
          "</sheet>\n"+
          ""
        #          oo.default_sheet = oo.sheets.first
        assert_equal expected, oo.to_xml
      end
    end
  end

  def test_invalid_iconv_from_ms
    #TODO: does only run within a darwin-environment
    if   RUBY_PLATFORM.downcase =~ /darwin/
      assert_nothing_raised() {
        oo = Excel.new(File.join("test","ms.xls"))
      }
    end
  end
  
end # class