caxlsx 3.2.0 → 3.4.0

data/test/workbook/worksheet/tc_date_time_converter.rb

@@ -1,124 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'tc_helper.rb'
-
-class TestDateTimeConverter < Test::Unit::TestCase
-  def setup
-    @margin_of_error = 0.000_001
-    @extended_time_range = begin
-      Time.parse "1893-08-05"
-      Time.parse "9999-12-31T23:59:59Z"
-      true
-    rescue
-      false
-    end
-  end
-
-  def test_date_to_serial_1900
-    Axlsx::Workbook.date1904 = false
-    tests = if @extended_time_range
-              { # examples taken straight from the spec
-                "1893-08-05" => -2338.0,
-                "1900-01-01" => 2.0,
-                "1910-02-03" => 3687.0,
-                "2006-02-01" => 38749.0,
-                "9999-12-31" => 2958465.0
-              }
-            else
-              { # examples taken inside the possible values
-                "1970-01-01" => 25569.0, # Unix epoch
-                "1970-01-02" => 25570.0,
-                "2006-02-01" => 38749.0,
-                "2038-01-19" => 50424.0, # max date using signed timestamp in 32bit
-              }
-            end
-    tests.each do |date_string, expected|
-      serial = Axlsx::DateTimeConverter::date_to_serial Date.parse(date_string)
-      assert_equal expected, serial
-    end
-  end
-
-  def test_date_to_serial_1904
-    Axlsx::Workbook.date1904 = true
-    tests = if @extended_time_range
-              { # examples taken straight from the spec
-                "1893-08-05" => -3800.0,
-                "1904-01-01" => 0.0,
-                "1910-02-03" => 2225.0,
-                "2006-02-01" => 37287.0,
-                "9999-12-31" => 2957003.0
-              }
-            else
-              { # examples taken inside the possible values
-                "1970-01-01" => 24107.0, # Unix epoch
-                "1970-01-02" => 24108.0,
-                "2006-02-01" => 37287.0,
-                "2038-01-19" => 48962.0, # max date using signed timestamp in 32bit
-              }
-            end
-    tests.each do |date_string, expected|
-      serial = Axlsx::DateTimeConverter::date_to_serial Date.parse(date_string)
-      assert_equal expected, serial
-    end
-  end
-
-  def test_time_to_serial_1900
-    Axlsx::Workbook.date1904 = false
-    tests = if @extended_time_range
-             { # examples taken straight from the spec
-               "1893-08-05T00:00:01Z" => -2337.999989,
-               "1899-12-28T18:00:00Z" => -1.25,
-               "1910-02-03T10:05:54Z" => 3687.4207639,
-               "1900-01-01T12:00:00Z" => 2.5, # wrongly indicated as 1.5 in the spec!
-               "9999-12-31T23:59:59Z" => 2958465.9999884
-             }
-           else
-             { # examples taken inside the possible values
-               "1970-01-01T00:00:00Z" => 25569.0, # Unix epoch
-               "1970-01-01T12:00:00Z" => 25569.5,
-               "2000-01-01T00:00:00Z" => 36526.0,
-               "2038-01-19T03:14:07Z" => 50424.134803, # max signed timestamp in 32bit
-             }
-           end
-    tests.each do |time_string, expected|
-      serial = Axlsx::DateTimeConverter::time_to_serial Time.parse(time_string)
-      assert_in_delta expected, serial, @margin_of_error
-    end
-  end
-
-  def test_time_to_serial_1904
-    Axlsx::Workbook.date1904 = true
-      # ruby 1.8.7 cannot parse dates prior to epoch. see http://ruby-doc.org/core-1.8.7/Time.html
-
-    tests = if @extended_time_range
-             { # examples taken straight from the spec
-               "1893-08-05T00:00:01Z" => -3799.999989,
-               "1910-02-03T10:05:54Z" => 2225.4207639,
-               "1904-01-01T12:00:00Z" => 0.5000000,
-               "9999-12-31T23:59:59Z" => 2957003.9999884
-             }
-           else
-             { # examples taken inside the possible values
-               "1970-01-01T00:00:00Z" => 24107.0, # Unix epoch
-               "1970-01-01T12:00:00Z" => 24107.5,
-               "2000-01-01T00:00:00Z" => 35064.0,
-               "2038-01-19T03:14:07Z" => 48962.134803, # max signed timestamp in 32bit
-             }
-           end
-    tests.each do |time_string, expected|
-      serial = Axlsx::DateTimeConverter::time_to_serial Time.parse(time_string)
-      assert_in_delta expected, serial, @margin_of_error
-    end
-  end
-
-  def test_timezone
-
-    utc = Time.utc 2012 # January 1st, 2012 at 0:00 UTC
-    local = Time.parse "2012-01-01 09:00:00 +0900"
-
-    assert_equal local, utc
-    assert_equal Axlsx::DateTimeConverter::time_to_serial(local) - local.utc_offset.to_f/86400,  Axlsx::DateTimeConverter::time_to_serial(utc)
-    Axlsx::Workbook.date1904 = true
-    assert_equal Axlsx::DateTimeConverter::time_to_serial(local) - local.utc_offset.to_f/86400, Axlsx::DateTimeConverter::time_to_serial(utc)
-  end
-
-end

data/test/workbook/worksheet/tc_header_footer.rb

@@ -1,151 +0,0 @@
-require 'tc_helper'
-
-class TestHeaderFooter < Test::Unit::TestCase
-
-  def setup
-    @p = Axlsx::Package.new
-    ws = @p.workbook.add_worksheet :name => 'test'
-    @hf = ws.header_footer
-  end
-
-  def test_initialize
-    assert_equal(nil, @hf.odd_header)
-    assert_equal(nil, @hf.odd_footer)
-
-    assert_equal(nil, @hf.even_header)
-    assert_equal(nil, @hf.even_footer)
-
-    assert_equal(nil, @hf.first_header)
-    assert_equal(nil, @hf.first_footer)
-
-    assert_equal(nil, @hf.different_first)
-    assert_equal(nil, @hf.different_odd_even)
-  end
-
-  def test_initialize_with_options
-    header_footer = {
-      :odd_header => 'oh',
-      :odd_footer => 'of',
-
-      :even_header => 'eh',
-      :even_footer => 'ef',
-
-      :first_header => 'fh',
-      :first_footer => 'ff',
-
-      :different_first => true,
-      :different_odd_even => true
-    }
-    optioned = @p.workbook.add_worksheet(:name => 'optioned', :header_footer => header_footer).header_footer
-
-    assert_equal('oh', optioned.odd_header)
-    assert_equal('of', optioned.odd_footer)
-
-    assert_equal('eh', optioned.even_header)
-    assert_equal('ef', optioned.even_footer)
-
-    assert_equal('fh', optioned.first_header)
-    assert_equal('ff', optioned.first_footer)
-
-    assert_equal(true, optioned.different_first)
-    assert_equal(true, optioned.different_odd_even)
-  end
-
-  def test_string_attributes
-    %w(odd_header odd_footer even_header even_footer first_header first_footer).each do |attr|
-      assert_raise(ArgumentError, 'only strings allowed in string attributes') { @hf.send("#{attr}=", 1) }
-      assert_nothing_raised { @hf.send("#{attr}=", 'test_string') }
-    end
-  end
-
-  def test_boolean_attributes
-   %w(different_first different_odd_even).each do |attr|
-      assert_raise(ArgumentError, 'only booleanish allowed in string attributes') { @hf.send("#{attr}=", 'foo') }
-      assert_nothing_raised { @hf.send("#{attr}=", 1) }
-    end
-  end
-
-  def test_set_all_values
-    @hf.set(
-      :odd_header => 'oh',
-      :odd_footer => 'of',
-
-      :even_header => 'eh',
-      :even_footer => 'ef',
-
-      :first_header => 'fh',
-      :first_footer => 'ff',
-
-      :different_first => true,
-      :different_odd_even => true
-    )
-
-    assert_equal('oh', @hf.odd_header)
-    assert_equal('of', @hf.odd_footer)
-
-    assert_equal('eh', @hf.even_header)
-    assert_equal('ef', @hf.even_footer)
-
-    assert_equal('fh', @hf.first_header)
-    assert_equal('ff', @hf.first_footer)
-
-    assert_equal(true, @hf.different_first)
-    assert_equal(true, @hf.different_odd_even)
-  end
-
-  def test_to_xml_all_values
-    @hf.set(
-      :odd_header => 'oh',
-      :odd_footer => 'of',
-
-      :even_header => 'eh',
-      :even_footer => 'ef',
-
-      :first_header => 'fh',
-      :first_footer => 'ff',
-
-      :different_first => true,
-      :different_odd_even => true
-    )
-
-    doc = Nokogiri::XML.parse(@hf.to_xml_string)
-    assert_equal(1, doc.xpath(".//headerFooter[@differentFirst=1][@differentOddEven=1]").size)
-
-    assert_equal(1, doc.xpath(".//headerFooter/oddHeader").size)
-    assert_equal('oh', doc.xpath(".//headerFooter/oddHeader").text)
-    assert_equal(1, doc.xpath(".//headerFooter/oddFooter").size)
-    assert_equal('of', doc.xpath(".//headerFooter/oddFooter").text)
-
-    assert_equal(1, doc.xpath(".//headerFooter/evenHeader").size)
-    assert_equal('eh', doc.xpath(".//headerFooter/evenHeader").text)
-    assert_equal(1, doc.xpath(".//headerFooter/evenFooter").size)
-    assert_equal('ef', doc.xpath(".//headerFooter/evenFooter").text)
-
-    assert_equal(1, doc.xpath(".//headerFooter/firstHeader").size)
-    assert_equal('fh', doc.xpath(".//headerFooter/firstHeader").text)
-    assert_equal(1, doc.xpath(".//headerFooter/firstFooter").size)
-    assert_equal('ff', doc.xpath(".//headerFooter/firstFooter").text)
-  end
-
-  def test_to_xml_some_values
-    @hf.set(
-      :odd_header => 'oh',
-      :different_odd_even => false
-    )
-
-    doc = Nokogiri::XML.parse(@hf.to_xml_string)
-    assert_equal(1, doc.xpath(".//headerFooter[@differentOddEven=0]").size)
-    assert_equal(0, doc.xpath(".//headerFooter[@differentFirst]").size)
-
-    assert_equal(1, doc.xpath(".//headerFooter/oddHeader").size)
-    assert_equal('oh', doc.xpath(".//headerFooter/oddHeader").text)
-    assert_equal(0, doc.xpath(".//headerFooter/oddFooter").size)
-
-    assert_equal(0, doc.xpath(".//headerFooter/evenHeader").size)
-    assert_equal(0, doc.xpath(".//headerFooter/evenFooter").size)
-
-    assert_equal(0, doc.xpath(".//headerFooter/firstHeader").size)
-    assert_equal(0, doc.xpath(".//headerFooter/firstFooter").size)
-  end
-end
-

data/test/workbook/worksheet/tc_icon_set.rb

@@ -1,45 +0,0 @@
-require 'tc_helper.rb'
-
-class TestIconSet < Test::Unit::TestCase
-  def setup
-    @icon_set = Axlsx::IconSet.new
-  end
-
-  def test_defaults
-    assert_equal @icon_set.iconSet, "3TrafficLights1"
-    assert_equal @icon_set.percent, true
-    assert_equal @icon_set.reverse, false
-    assert_equal @icon_set.showValue, true
-  end
-
-  def test_icon_set
-    assert_raise(ArgumentError) { @icon_set.iconSet = "invalid_value" }
-    assert_nothing_raised { @icon_set.iconSet = "5Rating"}
-    assert_equal(@icon_set.iconSet, "5Rating")
-  end
-
-  def test_percent
-    assert_raise(ArgumentError) { @icon_set.percent = :invalid_type }
-    assert_nothing_raised { @icon_set.percent =  false}
-    assert_equal(@icon_set.percent, false)
-  end
-
-  def test_showValue
-    assert_raise(ArgumentError) { @icon_set.showValue = :invalid_type }
-    assert_nothing_raised { @icon_set.showValue =  false}
-    assert_equal(@icon_set.showValue, false)
-  end
-
-  def test_reverse
-    assert_raise(ArgumentError) { @icon_set.reverse = :invalid_type }
-    assert_nothing_raised { @icon_set.reverse =  false}
-    assert_equal(@icon_set.reverse, false)
-  end
-
-  def test_to_xml_string
-    doc = Nokogiri::XML.parse(@icon_set.to_xml_string)
-    assert_equal(doc.xpath(".//iconSet[@iconSet='3TrafficLights1'][@percent=1][@reverse=0][@showValue=1]").size, 1)
-    assert_equal(doc.xpath(".//iconSet//cfvo").size, 3)
-  end
-
-end

data/test/workbook/worksheet/tc_outline_pr.rb

@@ -1,19 +0,0 @@
-require 'tc_helper.rb'
-
-class TestOutlinePr < Test::Unit::TestCase
- def setup
-   @outline_pr = Axlsx::OutlinePr.new(:summary_below => false, :summary_right => true, :apply_styles => false)
- end
-
- def test_summary_below
-   assert_equal false, @outline_pr.summary_below
- end
-
- def test_summary_right
-   assert_equal true, @outline_pr.summary_right
- end
- 
- def test_apply_styles
-   assert_equal false, @outline_pr.apply_styles
- end
-end

data/test/workbook/worksheet/tc_page_margins.rb

@@ -1,97 +0,0 @@
-require 'tc_helper.rb'
-
-class TestPageMargins < Test::Unit::TestCase
-
-  def setup
-    p = Axlsx::Package.new
-    ws = p.workbook.add_worksheet :name=>"hmmm"
-    @pm = ws.page_margins
-  end
-
-  def test_initialize
-    assert_equal(Axlsx::PageMargins::DEFAULT_LEFT_RIGHT, @pm.left)
-    assert_equal(Axlsx::PageMargins::DEFAULT_LEFT_RIGHT, @pm.right)
-    assert_equal(Axlsx::PageMargins::DEFAULT_TOP_BOTTOM, @pm.top)
-    assert_equal(Axlsx::PageMargins::DEFAULT_TOP_BOTTOM, @pm.bottom)
-    assert_equal(Axlsx::PageMargins::DEFAULT_HEADER_FOOTER, @pm.header)
-    assert_equal(Axlsx::PageMargins::DEFAULT_HEADER_FOOTER, @pm.footer)
-  end
-
-  def test_initialize_with_options
-    optioned = Axlsx::PageMargins.new(:left => 2, :right => 3, :top => 2, :bottom => 1, :header => 0.1, :footer => 0.1)
-    assert_equal(2, optioned.left)
-    assert_equal(3, optioned.right)
-    assert_equal(2, optioned.top)
-    assert_equal(1, optioned.bottom)
-    assert_equal(0.1, optioned.header)
-    assert_equal(0.1, optioned.footer)
-  end
-
-
-  def test_set_all_values
-    @pm.set(:left => 1.1, :right => 1.2, :top => 1.3, :bottom => 1.4, :header => 0.8, :footer => 0.9)
-    assert_equal(1.1, @pm.left)
-    assert_equal(1.2, @pm.right)
-    assert_equal(1.3, @pm.top)
-    assert_equal(1.4, @pm.bottom)
-    assert_equal(0.8, @pm.header)
-    assert_equal(0.9, @pm.footer)
-  end
-
-  def test_set_some_values
-    @pm.set(:left => 1.1, :right => 1.2)
-    assert_equal(1.1, @pm.left)
-    assert_equal(1.2, @pm.right)
-    assert_equal(Axlsx::PageMargins::DEFAULT_TOP_BOTTOM, @pm.top)
-    assert_equal(Axlsx::PageMargins::DEFAULT_TOP_BOTTOM, @pm.bottom)
-    assert_equal(Axlsx::PageMargins::DEFAULT_HEADER_FOOTER, @pm.header)
-    assert_equal(Axlsx::PageMargins::DEFAULT_HEADER_FOOTER, @pm.footer)
-  end
-
-  def test_to_xml
-    @pm.left = 1.1
-    @pm.right = 1.2
-    @pm.top = 1.3
-    @pm.bottom = 1.4
-    @pm.header = 0.8
-    @pm.footer = 0.9
-    doc = Nokogiri::XML.parse(@pm.to_xml_string)
-    assert_equal(1, doc.xpath(".//pageMargins[@left=1.1][@right=1.2][@top=1.3][@bottom=1.4][@header=0.8][@footer=0.9]").size)
-  end
-
-  def test_left
-    assert_raise(ArgumentError) { @pm.left = -1.2 }
-    assert_nothing_raised { @pm.left = 1.5 }
-    assert_equal(@pm.left, 1.5)
-  end
-
-  def test_right
-    assert_raise(ArgumentError) { @pm.right = -1.2 }
-    assert_nothing_raised { @pm.right = 1.5 }
-    assert_equal(@pm.right, 1.5)
-  end
-
-  def test_top
-    assert_raise(ArgumentError) { @pm.top = -1.2 }
-    assert_nothing_raised { @pm.top = 1.5 }
-    assert_equal(@pm.top, 1.5)
-  end
-
-  def test_bottom
-    assert_raise(ArgumentError) { @pm.bottom = -1.2 }
-    assert_nothing_raised { @pm.bottom = 1.5 }
-    assert_equal(@pm.bottom, 1.5)
-  end
-
-  def test_header
-    assert_raise(ArgumentError) { @pm.header = -1.2 }
-    assert_nothing_raised { @pm.header = 1.5 }
-    assert_equal(@pm.header, 1.5)
-  end
-
-  def test_footer
-    assert_raise(ArgumentError) { @pm.footer = -1.2 }
-    assert_nothing_raised { @pm.footer = 1.5 }
-    assert_equal(@pm.footer, 1.5)
-  end
-end

data/test/workbook/worksheet/tc_page_set_up_pr.rb

@@ -1,15 +0,0 @@
-require 'tc_helper.rb'
-
-class TestPageSetUpPr < Test::Unit::TestCase
- def setup
-   @page_setup_pr = Axlsx::PageSetUpPr.new(:fit_to_page => true, :auto_page_breaks => true)
- end
-
- def test_fit_to_page
-   assert_equal true, @page_setup_pr.fit_to_page
- end
-
- def test_auto_page_breaks
-   assert_equal true, @page_setup_pr.auto_page_breaks
- end
-end

data/test/workbook/worksheet/tc_page_setup.rb

@@ -1,143 +0,0 @@
-require 'tc_helper.rb'
-
-class TestPageSetup < Test::Unit::TestCase
-
-  def setup
-    @p = Axlsx::Package.new
-    ws = @p.workbook.add_worksheet :name => "hmmm"
-    @ps = ws.page_setup
-  end
-
-  def test_initialize
-    assert_equal(nil, @ps.fit_to_height)
-    assert_equal(nil, @ps.fit_to_width)
-    assert_equal(nil, @ps.orientation)
-    assert_equal(nil, @ps.paper_height)
-    assert_equal(nil, @ps.paper_width)
-    assert_equal(nil, @ps.scale)
-  end
-
-  def test_initialize_with_options
-    page_setup = { :fit_to_height => 1,
-                   :fit_to_width => 2,
-                   :orientation => :landscape,
-                   :paper_height => "297mm",
-                   :paper_width => "210mm",
-                   :scale => 50 }
-
-    optioned = @p.workbook.add_worksheet(:name => 'optioned', :page_setup => page_setup).page_setup
-    assert_equal(1, optioned.fit_to_height)
-    assert_equal(2, optioned.fit_to_width)
-    assert_equal(:landscape, optioned.orientation)
-    assert_equal("297mm", optioned.paper_height)
-    assert_equal("210mm", optioned.paper_width)
-    assert_equal(50, optioned.scale)
-  end
-
-  def test_set_all_values
-    @ps.set(:fit_to_height => 1, :fit_to_width => 2, :orientation => :landscape, :paper_height => "297mm", :paper_width => "210mm", :scale => 50)
-    assert_equal(1, @ps.fit_to_height)
-    assert_equal(2, @ps.fit_to_width)
-    assert_equal(:landscape, @ps.orientation)
-    assert_equal("297mm", @ps.paper_height)
-    assert_equal("210mm", @ps.paper_width)
-    assert_equal(50, @ps.scale)
-  end
-
-  def test_paper_size
-    assert_raise(ArgumentError) { @ps.paper_size = 119 }
-    assert_nothing_raised {  @ps.paper_size = 10 }
-  end
-
-  def test_set_some_values
-    @ps.set(:fit_to_width => 2, :orientation => :portrait)
-    assert_equal(2, @ps.fit_to_width)
-    assert_equal(:portrait, @ps.orientation)
-    assert_equal(nil, @ps.fit_to_height)
-    assert_equal(nil, @ps.paper_height)
-    assert_equal(nil, @ps.paper_width)
-    assert_equal(nil, @ps.scale)
-  end
-
-  def test_default_fit_to_page?
-    assert(@ps.fit_to_width == nil && @ps.fit_to_height == nil)
-    assert(@ps.fit_to_page? == false)
-  end
-
-  def test_with_height_fit_to_page?
-    assert(@ps.fit_to_width == nil && @ps.fit_to_height == nil)
-    @ps.set(:fit_to_height => 1)
-    assert(@ps.fit_to_page?)
-  end
-
-  def test_with_width_fit_to_page?
-    assert(@ps.fit_to_width == nil && @ps.fit_to_height == nil)
-    @ps.set(:fit_to_width => 1)
-    assert(@ps.fit_to_page?)
-  end
-
-  def test_to_xml_all_values
-    @ps.set(:fit_to_height => 1, :fit_to_width => 2, :orientation => :landscape, :paper_height => "297mm", :paper_width => "210mm", :scale => 50)
-    doc = Nokogiri::XML.parse(@ps.to_xml_string)
-    assert_equal(1, doc.xpath(".//pageSetup[@fitToHeight='1'][@fitToWidth='2'][@orientation='landscape'][@paperHeight='297mm'][@paperWidth='210mm'][@scale='50']").size)
-  end
-
-  def test_to_xml_some_values
-    @ps.set(:orientation => :portrait)
-    doc = Nokogiri::XML.parse(@ps.to_xml_string)
-    assert_equal(1, doc.xpath(".//pageSetup[@orientation='portrait']").size)
-    assert_equal(0, doc.xpath(".//pageSetup[@fitToHeight]").size)
-    assert_equal(0, doc.xpath(".//pageSetup[@fitToWidth]").size)
-    assert_equal(0, doc.xpath(".//pageSetup[@paperHeight]").size)
-    assert_equal(0, doc.xpath(".//pageSetup[@paperWidth]").size)
-    assert_equal(0, doc.xpath(".//pageSetup[@scale]").size)
-  end
-
-  def test_fit_to_height
-    assert_raise(ArgumentError) { @ps.fit_to_height = 1.5 }
-    assert_nothing_raised { @ps.fit_to_height = 2 }
-    assert_equal(2, @ps.fit_to_height)
-  end
-
-  def test_fit_to_width
-    assert_raise(ArgumentError) { @ps.fit_to_width = false }
-    assert_nothing_raised { @ps.fit_to_width = 1 }
-    assert_equal(1, @ps.fit_to_width)
-  end
-
-  def test_orientation
-    assert_raise(ArgumentError) { @ps.orientation = "" }
-    assert_nothing_raised { @ps.orientation = :default }
-    assert_equal(:default, @ps.orientation)
-  end
-
-  def test_paper_height
-    assert_raise(ArgumentError) { @ps.paper_height = 99 }
-    assert_nothing_raised { @ps.paper_height = "11in" }
-    assert_equal("11in", @ps.paper_height)
-  end
-
-  def test_paper_width
-    assert_raise(ArgumentError) { @ps.paper_width = "22" }
-    assert_nothing_raised { @ps.paper_width = "29.7cm" }
-    assert_equal("29.7cm", @ps.paper_width)
-  end
-
-  def test_scale
-    assert_raise(ArgumentError) { @ps.scale = 50.5 }
-    assert_nothing_raised { @ps.scale = 99 }
-    assert_equal(99, @ps.scale)
-  end
-
-  def test_fit_to
-    fits = @ps.fit_to(:width => 1)
-    assert_equal([1, 999], fits)
-    fits = @ps.fit_to :height => 1
-    assert_equal(fits, [999 ,1])
-    fits = @ps.fit_to :height => 7, :width => 2
-    assert_equal(fits, [2, 7])
-    assert_raise(ArgumentError) { puts @ps.fit_to(:width => true)}
-
-
-  end
-end

data/test/workbook/worksheet/tc_pane.rb

@@ -1,54 +0,0 @@
-# encoding: UTF-8
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../../"
-require 'tc_helper.rb'
-
-class TestPane < Test::Unit::TestCase
-  def setup
-    #inverse defaults for booleans
-    @nil_options = { :active_pane => :bottom_left, :state => :frozen, :top_left_cell => 'A2' }
-    @int_0_options = { :x_split => 2, :y_split => 2 }
-   @options = @nil_options.merge(@int_0_options)
-    @pane = Axlsx::Pane.new(@options)
-  end
-
-
-  def test_active_pane
-    assert_raise(ArgumentError) { @pane.active_pane = "10" }
-    assert_nothing_raised { @pane.active_pane = :top_left }
-    assert_equal(@pane.active_pane, "topLeft")
-  end
-  
-  def test_state
-    assert_raise(ArgumentError) { @pane.state = "foo" }
-    assert_nothing_raised { @pane.state = :frozen_split }
-    assert_equal(@pane.state, "frozenSplit")
-  end
-  
-  def test_x_split
-    assert_raise(ArgumentError) { @pane.x_split = "foo´" }
-    assert_nothing_raised { @pane.x_split = 200 }
-    assert_equal(@pane.x_split, 200)
-  end
-  
-  def test_y_split
-    assert_raise(ArgumentError) { @pane.y_split = 'foo' }
-    assert_nothing_raised { @pane.y_split = 300 }
-    assert_equal(@pane.y_split, 300)
-  end
-  
-  def test_top_left_cell
-    assert_raise(ArgumentError) { @pane.top_left_cell = :cell }
-    assert_nothing_raised { @pane.top_left_cell = "A2" }
-    assert_equal(@pane.top_left_cell, "A2")
-  end
-  
-  def test_to_xml
-    doc = Nokogiri::XML.parse(@pane.to_xml_string)
-    assert_equal(1, doc.xpath("//pane[@ySplit=2][@xSplit='2'][@topLeftCell='A2'][@state='frozen'][@activePane='bottomLeft']").size)
-  end
-  def test_to_xml_frozen
-    pane = Axlsx::Pane.new :state => :frozen, :y_split => 2
-    doc = Nokogiri::XML(pane.to_xml_string)
-    assert_equal(1, doc.xpath("//pane[@topLeftCell='A3']").size)
-  end
-end