axlsx 1.2.0 → 2.0.0

data/test/rels/tc_relationship.rb

@@ -1,21 +1,44 @@
 require 'tc_helper.rb'
 
 class TestRelationships < Test::Unit::TestCase
-  def setup
+  
+  def test_instances_with_different_attributes_have_unique_ids
+    rel_1 = Axlsx::Relationship.new(Object.new, Axlsx::WORKSHEET_R, 'target')
+    rel_2 = Axlsx::Relationship.new(Object.new, Axlsx::COMMENT_R, 'foobar')
+    assert_not_equal rel_1.Id, rel_2.Id
   end
-
-  def teardown
+  
+  def test_instances_with_same_attributes_share_id
+    source_obj = Object.new
+    instance = Axlsx::Relationship.new(source_obj, Axlsx::WORKSHEET_R, 'target')
+    assert_equal instance.Id, Axlsx::Relationship.new(source_obj, Axlsx::WORKSHEET_R, 'target').Id
   end
-
+  
+  def test_target_is_only_considered_for_same_attributes_check_if_target_mode_is_external
+    source_obj = Object.new
+    rel_1 = Axlsx::Relationship.new(source_obj, Axlsx::WORKSHEET_R, 'target')
+    rel_2 = Axlsx::Relationship.new(source_obj, Axlsx::WORKSHEET_R, '../target')
+    assert_equal rel_1.Id, rel_2.Id
+    
+    rel_3 = Axlsx::Relationship.new(source_obj, Axlsx::HYPERLINK_R, 'target', :target_mode => :External)
+    rel_4 = Axlsx::Relationship.new(source_obj, Axlsx::HYPERLINK_R, '../target', :target_mode => :External)
+    assert_not_equal rel_3.Id, rel_4.Id
+  end
+  
   def test_type
-    assert_raise(ArgumentError) { Axlsx::Relationship.new 'type', 'target' }
-    assert_nothing_raised { Axlsx::Relationship.new Axlsx::WORKSHEET_R, 'target' }
-    assert_nothing_raised { Axlsx::Relationship.new Axlsx::COMMENT_R, 'target' }
+    assert_raise(ArgumentError) { Axlsx::Relationship.new nil, 'type', 'target' }
+    assert_nothing_raised { Axlsx::Relationship.new nil, Axlsx::WORKSHEET_R, 'target' }
+    assert_nothing_raised { Axlsx::Relationship.new nil, Axlsx::COMMENT_R, 'target' }
   end
 
   def test_target_mode
-    assert_raise(ArgumentError) { Axlsx::Relationship.new 'type', 'target', :target_mode => "FISH" }
-    assert_nothing_raised { Axlsx::Relationship.new( Axlsx::WORKSHEET_R, 'target', :target_mode => :External) }
+    assert_raise(ArgumentError) { Axlsx::Relationship.new nil, 'type', 'target', :target_mode => "FISH" }
+    assert_nothing_raised { Axlsx::Relationship.new( nil, Axlsx::WORKSHEET_R, 'target', :target_mode => :External) }
   end
 
+  def test_ampersand_escaping_in_target
+    r = Axlsx::Relationship.new(nil, Axlsx::HYPERLINK_R, "http://example.com?foo=1&bar=2", :target_mod => :External)
+    doc = Nokogiri::XML(r.to_xml_string)
+    assert_equal(doc.xpath("//Relationship[@Target='http://example.com?foo=1&bar=2']").size, 1)
+  end
 end

data/test/rels/tc_relationships.rb

@@ -2,6 +2,17 @@ require 'tc_helper.rb'
 
 class TestRelationships < Test::Unit::TestCase
 
+  def test_for
+    source_obj_1, source_obj_2 = Object.new, Object.new
+    rel_1 = Axlsx::Relationship.new(source_obj_1, Axlsx::WORKSHEET_R, "bar")
+    rel_2 = Axlsx::Relationship.new(source_obj_2, Axlsx::WORKSHEET_R, "bar")
+    rels = Axlsx::Relationships.new
+    rels << rel_1 
+    rels << rel_2
+    assert_equal rel_1, rels.for(source_obj_1)
+    assert_equal rel_2, rels.for(source_obj_2)
+  end
+  
   def test_valid_document
     @rels = Axlsx::Relationships.new
     schema = Nokogiri::XML::Schema(File.open(Axlsx::RELS_XSD))
@@ -12,7 +23,7 @@ class TestRelationships < Test::Unit::TestCase
       errors << error
     end
 
-    @rels << Axlsx::Relationship.new(Axlsx::WORKSHEET_R, "bar")
+    @rels << Axlsx::Relationship.new(nil, Axlsx::WORKSHEET_R, "bar")
     doc = Nokogiri::XML(@rels.to_xml_string)
     errors = []
     schema.validate(doc).each do |error|

data/test/stylesheet/tc_color.rb

@@ -27,6 +27,12 @@ class TestColor < Test::Unit::TestCase
     assert_equal(@item.rgb, "FF00FF00" )
   end
 
+  def test_rgb_writer_doesnt_mutate_its_argument
+    my_rgb = 'ff00ff00'
+    @item.rgb = my_rgb
+    assert_equal 'ff00ff00', my_rgb
+  end
+
   def test_tint
     assert_raise(ArgumentError) { @item.tint = -1 }
     assert_nothing_raised { @item.tint = -1.0 }

data/test/stylesheet/tc_styles.rb

@@ -105,6 +105,19 @@ class TestStyles < Test::Unit::TestCase
     assert(@styles.parse_alignment_options(:alignment => {}).is_a?(Axlsx::CellAlignment))
   end
 
+  def test_parse_font_using_defaults
+    original = @styles.fonts.first
+    @styles.add_style :b => 1, :sz => 99
+    created = @styles.fonts.last
+    original_attributes = original.instance_values
+    assert_equal(1, created.b)
+    assert_equal(99, created.sz)
+    copied = original_attributes.reject{ |key, value| %w(b sz).include? key }
+    copied.each do |key, value|
+      assert_equal(created.instance_values[key], value)
+    end
+  end
+
   def test_parse_font_options
     options = {
       :fg_color => "FF050505",
@@ -137,7 +150,7 @@ class TestStyles < Test::Unit::TestCase
     assert_equal(@styles.parse_fill_options(:bg_color => "DE").class, Fixnum, "return index of fill if not :dxf type")
     assert_equal(@styles.parse_fill_options(:bg_color => "DE", :type => :dxf).class, Axlsx::Fill, "return fill object if :dxf type")
     f = @styles.parse_fill_options(:bg_color => "DE", :type => :dxf)
-    assert(f.fill_type.fgColor.rgb == "FFDEDEDE")
+    assert(f.fill_type.bgColor.rgb == "FFDEDEDE")
   end
 
   def test_parse_protection_options
@@ -197,7 +210,7 @@ class TestStyles < Test::Unit::TestCase
     assert_equal(0, style, "returns the zero-based dxfId")
 
     dxf = @styles.dxfs.last
-    assert_equal(@styles.dxfs.last.fill.fill_type.fgColor.rgb, "FF000000", "fill created with color")
+    assert_equal(@styles.dxfs.last.fill.fill_type.bgColor.rgb, "FF000000", "fill created with color")
 
     assert_equal(font_count, (@styles.fonts.size), "font not created under styles")
     assert_equal(fill_count, (@styles.fills.size), "fill not created under styles")

data/test/tc_axlsx.rb

@@ -14,8 +14,35 @@ class TestAxlsx < Test::Unit::TestCase
     }
   end
 
-  def test_cell_range
-    #To do
+  def test_cell_range_empty_if_no_cell
+    assert_equal(Axlsx.cell_range([]), "")
+  end
+
+  def test_do_not_trust_input_by_default
+    assert_equal false, Axlsx.trust_input
+  end
+
+
+  def test_trust_input_can_be_set_to_true
+    Axlsx.trust_input = true
+    assert_equal true, Axlsx.trust_input
+  end
+  def test_cell_range_relative
+    p = Axlsx::Package.new
+    ws = p.workbook.add_worksheet
+    row = ws.add_row
+    c1 = row.add_cell
+    c2 = row.add_cell
+    assert_equal(Axlsx.cell_range([c2, c1], false), "A1:B1")
+  end
+
+  def test_cell_range_absolute
+    p = Axlsx::Package.new
+    ws = p.workbook.add_worksheet :name => "Sheet <'>\" 1"
+    row = ws.add_row
+    c1 = row.add_cell
+    c2 = row.add_cell
+    assert_equal(Axlsx.cell_range([c2, c1], true), "'Sheet &lt;''&gt;&quot; 1'!$A$1:$B$1")
   end
 
   def test_name_to_indices
@@ -36,4 +63,10 @@ class TestAxlsx < Test::Unit::TestCase
     # todo
   end
 
+  def test_range_to_a
+    assert_equal([['A1', 'B1', 'C1']],                         Axlsx::range_to_a('A1:C1'))
+    assert_equal([['A1', 'B1', 'C1'], ['A2', 'B2', 'C2']],     Axlsx::range_to_a('A1:C2'))
+    assert_equal([['Z5', 'AA5', 'AB5'], ['Z6', 'AA6', 'AB6']], Axlsx::range_to_a('Z5:AB6'))
+  end
+
 end

data/test/tc_helper.rb

@@ -1,4 +1,10 @@
 $LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-require 'cover_me' unless RUBY_VERSION == '1.8.7'
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/test/"
+  add_filter "/vendor/"
+end
+
 require 'test/unit'
+require "timecop"
 require "axlsx.rb"

data/test/tc_package.rb

@@ -7,6 +7,9 @@ class TestPackage < Test::Unit::TestCase
     ws = @package.workbook.add_worksheet
     ws.add_row ['Can', 'we', 'build it?']
     ws.add_row ['Yes!', 'We', 'can!']
+    ws.outline_level_rows 0, 1
+    ws.outline_level_columns 0, 1
+    ws.add_hyperlink :ref => ws.rows.first.cells.last, :location => 'https://github.com/randym'
     ws.workbook.add_defined_name("#{ws.name}!A1:C2", :name => '_xlnm.Print_Titles', :hidden => true)
     ws.protect_range('A1:C1')
     ws.protect_range(ws.rows.last.cells)
@@ -37,15 +40,15 @@ class TestPackage < Test::Unit::TestCase
     ws.add_chart(Axlsx::Line3DChart, :title => "axis labels") do |chart|
       chart.valAxis.title = 'bob'
       chart.d_lbls.show_val = true
-    end 
-    
+    end
+
     ws.add_chart(Axlsx::Bar3DChart, :title => 'bar chart') do |chart|
       chart.add_series :data => [1,4,5], :labels => %w(A B C)
       chart.d_lbls.show_percent = true
     end
 
     ws.add_chart(Axlsx::ScatterChart, :title => 'scat man') do |chart|
-      chart.add_series :xData => [1,2,3,4], :yData => [4,3,2,1] 
+      chart.add_series :xData => [1,2,3,4], :yData => [4,3,2,1]
       chart.d_lbls.show_val = true
     end
 
@@ -56,11 +59,12 @@ class TestPackage < Test::Unit::TestCase
       image.height=666
       image.hyperlink.tooltip = "Labeled Link"
       image.start_at 5, 5
+      image.end_at 10, 10
     end
     ws.add_image :image_src => File.expand_path('../../examples/image1.gif', __FILE__) do |image|
       image.start_at 0, 20
       image.width=360
-      image.height=333 
+      image.height=333
     end
     ws.add_image :image_src => File.expand_path('../../examples/image1.png', __FILE__) do |image|
       image.start_at 9, 20
@@ -68,6 +72,11 @@ class TestPackage < Test::Unit::TestCase
       image.height = 167
     end
     ws.add_table 'A1:C1'
+
+    ws.add_pivot_table 'G5:G6', 'A1:B3'
+
+    ws.add_page_break "B2"
+
   end
 
   def test_use_autowidth
@@ -99,6 +108,12 @@ class TestPackage < Test::Unit::TestCase
     assert(Axlsx::Package.new.workbook.worksheets.size == 0, 'Workbook should not have sheets by default')
   end
 
+  def test_created_at_is_propagated_to_core
+    time = Time.utc(2013, 1, 1, 12, 0)
+    p = Axlsx::Package.new :created_at => time
+    assert_equal(time, p.core.created)
+  end
+
   def test_serialization
     assert_nothing_raised do
       begin
@@ -111,6 +126,27 @@ class TestPackage < Test::Unit::TestCase
       end
     end
   end
+  
+  # See comment for Package#zip_entry_for_part
+  def test_serialization_creates_identical_files_at_any_time_if_created_at_is_set
+    @package.core.created = Time.now
+    zip_content_now = @package.to_stream.string
+    Timecop.travel(3600) do
+      zip_content_then = @package.to_stream.string
+      assert zip_content_then == zip_content_now, "zip files are not identical"
+    end
+  end
+  
+  def test_serialization_creates_identical_files_for_identical_packages
+    package_1, package_2 = 2.times.map do 
+      Axlsx::Package.new(:created_at => Time.utc(2013, 1, 1)).tap do |p|
+        p.workbook.add_worksheet(:name => "Basic Worksheet") do |sheet|
+          sheet.add_row [1, 2, 3]
+        end
+      end
+    end
+    assert package_1.to_stream.string == package_2.to_stream.string, "zip files are not identical"
+  end
 
   def test_validation
     assert_equal(@package.validate.size, 0, @package.validate)
@@ -134,10 +170,13 @@ class TestPackage < Test::Unit::TestCase
     assert_equal(p.select{ |part| part[:entry] =~ /xl\/worksheets\/sheet\d\.xml/ }.size, @package.workbook.worksheets.size, "one or more sheet missing")
     assert_equal(p.select{ |part| part[:entry] =~ /xl\/worksheets\/_rels\/sheet\d\.xml\.rels/ }.size, @package.workbook.worksheets.size, "one or more sheet rels missing")
     assert_equal(p.select{ |part| part[:entry] =~ /xl\/comments\d\.xml/ }.size, @package.workbook.worksheets.size, "one or more sheet rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/pivotTables\/pivotTable\d\.xml/ }.size, @package.workbook.worksheets.first.pivot_tables.size, "one or more pivot tables missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/pivotTables\/_rels\/pivotTable\d\.xml.rels/ }.size, @package.workbook.worksheets.first.pivot_tables.size, "one or more pivot tables rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/pivotCache\/pivotCacheDefinition\d\.xml/ }.size, @package.workbook.worksheets.first.pivot_tables.size, "one or more pivot tables missing")
 
 
     #no mystery parts
-    assert_equal(p.size, 21)
+    assert_equal(24, p.size)
 
   end
 

data/test/util/tc_serialized_attributes.rb

@@ -0,0 +1,19 @@
+require 'tc_helper.rb'
+class Funk
+  include Axlsx::Accessors
+  include Axlsx::SerializedAttributes
+  serializable_attributes :camel_symbol, :boolean, :integer
+
+  attr_accessor :camel_symbol, :boolean, :integer
+end
+
+class TestSeralizedAttributes < Test::Unit::TestCase
+  def setup
+    @object = Funk.new
+  end
+
+  def test_camel_symbol
+    @object.camel_symbol = :foo_bar
+    assert_equal('camelSymbol="fooBar" ', @object.serialized_attributes)
+  end
+end

data/test/util/tc_validators.rb

@@ -158,4 +158,29 @@ class TestValidators < Test::Unit::TestCase
     assert_raise(ArgumentError) { Axlsx.validate_split_state_type 'frozen_split' }
     assert_raise(ArgumentError) { Axlsx.validate_split_state_type 0 }
   end
-end
+ 
+  def test_validate_integerish
+    assert_raise(ArgumentError) { Axlsx.validate_integerish Axlsx }
+    [1, 1.4, "a"].each { |test_value| assert_nothing_raised { Axlsx.validate_integerish test_value } }
+  end
+  def test_validate_family
+    assert_raise(ArgumentError) { Axlsx.validate_family 0 }
+    (1..5).each do |item|
+      assert_nothing_raised { Axlsx.validate_family item }
+    end
+  end
+
+  def test_validate_u
+    assert_raise(ArgumentError) { Axlsx.validate_cell_u :hoge }
+    [:none, :single, :double, :singleAccounting, :doubleAccounting].each do |sym|
+      assert_nothing_raised { Axlsx.validate_cell_u sym }
+    end
+  end
+
+  def test_range_validation
+     # exclusive
+     assert_raise(ArgumentError) { Axlsx::RangeValidator.validate('foo', 1, 10, 10, false) } 
+     # inclusive by default
+     assert_nothing_raised { Axlsx::RangeValidator.validate('foo', 1, 10, 10) }
+  end
+end

data/test/workbook/tc_defined_name.rb

@@ -10,14 +10,14 @@ class TestDefinedNames < Test::Unit::TestCase
   end
   
   def test_string_attributes
-    Axlsx::DefinedName::STRING_ATTRIBUTES.each do |attr|
+    %w(short_cut_key status_bar help description custom_menu comment).each do |attr|
       assert_raise(ArgumentError, 'only strings allowed in string attributes') { @dn.send("#{attr}=", 1) }
       assert_nothing_raised { @dn.send("#{attr}=", '_xlnm.Sheet_Title') }
     end
   end
 
   def test_boolean_attributes
-   Axlsx::DefinedName::BOOLEAN_ATTRIBUTES.each do |attr|
+   %w(workbook_parameter publish_to_server xlm vb_proceedure function hidden).each do |attr|
       assert_raise(ArgumentError, 'only booleanish allowed in string attributes') { @dn.send("#{attr}=", 'foo') }
       assert_nothing_raised { @dn.send("#{attr}=", 1) }
     end

data/test/workbook/tc_shared_strings_table.rb

@@ -24,6 +24,12 @@ class TestSharedStringsTable < Test::Unit::TestCase
     assert_equal(sst.unique_count, 4)
   end
 
+  def test_uses_workbook_xml_space
+    assert_equal(@p.workbook.xml_space, @p.workbook.shared_strings.xml_space)
+    @p.workbook.xml_space = :default
+    assert_equal(:default, @p.workbook.shared_strings.xml_space)
+  end
+
   def test_valid_document
     schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
     doc = Nokogiri::XML(@p.workbook.shared_strings.to_xml_string)

data/test/workbook/tc_workbook.rb

@@ -9,6 +9,23 @@ class TestWorkbook < Test::Unit::TestCase
   def teardown
   end
 
+  def test_worksheet_users_xml_space
+    sheet = @wb.add_worksheet(:name => 'foo')
+    ws_xml = Nokogiri::XML(sheet.to_xml_string)
+    assert(ws_xml.xpath("//xmlns:worksheet/@xml:space='preserve'"))
+
+    @wb.xml_space = :default
+    ws_xml = Nokogiri::XML(sheet.to_xml_string)
+    assert(ws_xml.xpath("//xmlns:worksheet/@xml:space='default'"))
+  end
+
+  def test_xml_space
+    assert_equal(:preserve, @wb.xml_space)
+    @wb.xml_space = :default
+    assert_equal(:default, @wb.xml_space)
+    assert_raise(ArgumentError) { @wb.xml_space = :none }
+  end
+
   def test_no_autowidth
     assert_equal(@wb.use_autowidth, true)
     assert_raise(ArgumentError) {@wb.use_autowidth = 0.1}
@@ -16,6 +33,13 @@ class TestWorkbook < Test::Unit::TestCase
     assert_equal(@wb.use_autowidth, false)
   end
 
+
+  def test_sheet_by_name_retrieval
+    @wb.add_worksheet(:name=>'foo')
+    @wb.add_worksheet(:name=>'bar')
+    assert_equal('foo', @wb.sheet_by_name('foo').name)
+    
+  end
   def test_date1904
     assert_equal(Axlsx::Workbook.date1904, @wb.date1904)
     @wb.date1904 = :false
@@ -42,6 +66,14 @@ class TestWorkbook < Test::Unit::TestCase
     assert_equal(@wb.worksheets.first, ws, "the worksheet returned is the worksheet added")
     assert_equal(ws.name, "bob", "name option gets passed to worksheet")
   end
+  
+  def test_insert_worksheet
+    @wb.add_worksheet(:name => 'A')
+    @wb.add_worksheet(:name => 'B')
+    ws3 = @wb.insert_worksheet(0, :name => 'C')
+    assert_equal(ws3.name, @wb.worksheets.first.name)
+  end
+
   def test_relationships
     #current relationship size is 1 due to style relation
     assert(@wb.relationships.size == 1)
@@ -84,5 +116,10 @@ class TestWorkbook < Test::Unit::TestCase
     assert_equal(doc.xpath('//xmlns:workbook/xmlns:definedNames/xmlns:definedName').inner_text, @wb.worksheets[0].auto_filter.defined_name)
   end
 
-
+  def test_to_xml_uses_correct_rIds_for_pivotCache
+    ws = @wb.add_worksheet
+    pivot_table = ws.add_pivot_table('G5:G6', 'A1:D5')
+    doc = Nokogiri::XML(@wb.to_xml_string)
+    assert_equal pivot_table.cache_definition.rId, doc.xpath("//xmlns:pivotCache").first["r:id"]
+  end
 end

data/test/workbook/worksheet/auto_filter/tc_auto_filter.rb

@@ -0,0 +1,38 @@
+require 'tc_helper.rb'
+
+class TestAutoFilter < Test::Unit::TestCase
+
+  def setup
+    ws = Axlsx::Package.new.workbook.add_worksheet
+    3.times { |index| ws.add_row [1*index,2*index,3*index] }
+    @auto_filter = ws.auto_filter
+    @auto_filter.range = 'A1:C3'
+    @auto_filter.add_column 0, :filters, :filter_items => [1]
+  end
+
+  def test_defined_name
+    assert_equal("'Sheet1'!$A$1:$C$3", @auto_filter.defined_name)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@auto_filter.to_xml_string)
+    assert(doc.xpath("autoFilter[@ref='#{@auto_filter.range}']"))
+  end
+
+  def test_columns
+    assert @auto_filter.columns.is_a?(Axlsx::SimpleTypedList)
+    assert_equal @auto_filter.columns.allowed_types, [Axlsx::FilterColumn]
+  end
+
+  def test_add_column
+    @auto_filter.add_column(0, :filters) do |column|
+      assert column.is_a? FilterColumn
+    end
+  end
+
+  def test_applya
+    assert_equal nil, @auto_filter.worksheet.rows.last.hidden
+    @auto_filter.apply
+    assert_equal true, @auto_filter.worksheet.rows.last.hidden
+  end
+end

data/test/workbook/worksheet/auto_filter/tc_filter_column.rb

@@ -0,0 +1,76 @@
+require 'tc_helper.rb'
+
+class TestFilterColumn < Test::Unit::TestCase
+
+  def setup
+    @filter_column = Axlsx::FilterColumn.new(0, :filters, :filter_items => [200])
+  end
+
+
+  def test_initialize_col_id
+    assert_raise ArgumentError do
+      Axlsx::FilterColumn.new(0, :bobs_house_of_filter)
+    end 
+    assert_raise ArgumentError do 
+      Axlsx::FilterColumn.new(:penut, :filters)
+    end 
+  end
+
+  def test_initailize_filter_type
+    assert @filter_column.filter.is_a?(Axlsx::Filters)
+    assert_equal 1, @filter_column.filter.filter_items.size
+  end
+
+  def test_initialize_filter_type_filters_with_options
+    assert_equal 200, @filter_column.filter.filter_items.first.val
+  end
+
+  def test_initialize_with_block
+    filter_column = Axlsx::FilterColumn.new(0, :filters) do |filters|
+      filters.filter_items = [700, 100, 5]
+    end
+    assert_equal 3, filter_column.filter.filter_items.size
+    assert_equal 700, filter_column.filter.filter_items.first.val
+    assert_equal 5, filter_column.filter.filter_items.last.val
+  end
+
+  def test_default_show_button
+    assert_equal true, @filter_column.show_button
+  end
+
+  def test_default_hidden_button
+    assert_equal false, @filter_column.hidden_button
+  end
+
+  def test_show_button
+    assert_raise ArgumentError do
+      @filter_column.show_button = :foo 
+    end
+    assert_nothing_raised { @filter_column.show_button = false }
+  end
+
+  def test_hidden_button
+    assert_raise ArgumentError do
+      @filter_column.hidden_button = :hoge
+    end 
+    assert_nothing_raised { @filter_column.hidden_button = true }
+  end
+
+  def test_col_id=
+    assert_raise ArgumentError do 
+    @filter_column.col_id = :bar
+    end 
+  assert_nothing_raised { @filter_column.col_id = 7 }
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@filter_column.to_xml_string)
+    assert doc.xpath("//filterColumn[@colId=#{@filter_column.col_id}]")
+    assert doc.xpath("//filterColumn[@hiddenButton=#{@filter_column.hidden_button}]")
+    assert doc.xpath("//filterColumn[@showButton=#{@filter_column.show_button}]")
+
+
+
+    assert doc.xpath("//filterColumn/filters")
+  end
+end

data/test/workbook/worksheet/auto_filter/tc_filters.rb

@@ -0,0 +1,50 @@
+require 'tc_helper.rb'
+
+class TestFilters < Test::Unit::TestCase
+  def setup
+    @filters = Axlsx::Filters.new(:filter_items => [1, 'a'], 
+                                  :date_group_items =>[ { :date_time_grouping => :year, :year => 2011, :month => 11, :day => 11, :hour => 0, :minute => 0, :second => 0 } ] , 
+                                  :blank => true)
+  end
+
+  def test_blank
+    assert_equal true, @filters.blank
+    assert_raise(ArgumentError) { @filters.blank = :only_if_you_want_it }
+    @filters.blank = true
+    assert_equal true, @filters.blank
+  end
+
+  def test_calendar_type
+    assert_raise(ArgumentError) { @filters.calendar_type = 'monkey calendar' }
+    @filters.calendar_type = 'japan'
+    assert_equal('japan', @filters.calendar_type)
+  end
+
+  def test_filters_items
+    assert @filters.filter_items.is_a?(Array)
+    assert_equal 2, @filters.filter_items.size
+  end
+
+  def test_date_group_items
+    assert @filters.date_group_items.is_a?(Array)
+    assert_equal 1, @filters.date_group_items.size
+  end
+ 
+  def test_apply_is_false_for_matching_values
+    keeper = Object.new
+    def keeper.value; 'a'; end 
+    assert_equal false, @filters.apply(keeper)
+  end
+
+  def test_apply_is_true_for_non_matching_values
+    hidden = Object.new 
+    def hidden.value; 'b'; end
+    assert_equal true, @filters.apply(hidden)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@filters.to_xml_string)
+    assert_equal(1, doc.xpath('//filters[@blank="true"]').size)
+  end
+end
+

data/test/workbook/worksheet/tc_break.rb

@@ -0,0 +1,49 @@
+require 'tc_helper.rb'
+
+class TestBreak < Test::Unit::TestCase
+
+  def setup
+    @break = Axlsx::Break.new(:id => 1, :min => 1, :max => 10, :man => true, :pt => false)
+  end
+
+  def test_id
+    assert_equal(1, @break.id)
+    assert_raises ArgumentError do
+      Axlsx::Break.new(:hoge, {:id => -1})
+    end
+  end
+
+  def test_min
+    assert_equal(1, @break.min)
+    assert_raises ArgumentError do
+      Axlsx::Break.new(:hoge, :min => -1)
+    end
+  end
+
+  def test_max
+    assert_equal(10, @break.max)
+    assert_raises ArgumentError do
+      Axlsx::Break.new(:hoge, :max => -1)
+    end
+  end
+
+
+  def test_man
+    assert_equal(true, @break.man)
+    assert_raises ArgumentError do
+      Axlsx::Break.new(:man => -1)
+    end
+  end
+
+  def test_pt
+    assert_equal(false, @break.pt)
+    assert_raises ArgumentError do
+      Axlsx::Break.new(:pt => -1)
+    end
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@break.to_xml_string)
+    assert_equal(doc.xpath('//brk[@id="1"][@min="1"][@max="10"][@pt="false"][@man="true"]').size, 1)
+  end
+end