axlsx 1.0.15 → 1.1.1

data/test/tc_package.rb

@@ -1,8 +1,7 @@
-require 'test/unit'
-require 'axlsx.rb'
+require 'tc_helper.rb'
 
 class TestPackage < Test::Unit::TestCase
-  def setup    
+  def setup
     @package = Axlsx::Package.new
     ws = @package.workbook.add_worksheet
     chart = ws.add_chart Axlsx::Pie3DChart
@@ -21,6 +20,13 @@ class TestPackage < Test::Unit::TestCase
     assert_raise(NoMethodError) {@package.app = nil }
   end
 
+  def test_use_shared_strings
+    assert_equal(@package.use_shared_strings, nil)
+    assert_raise(ArgumentError) {@package.use_shared_strings 9}
+    assert_nothing_raised {@package.use_shared_strings = true}
+    assert_equal(@package.use_shared_strings, @package.workbook.use_shared_strings)
+  end
+
   def test_default_objects_are_created
     assert(@package.instance_values["app"].is_a?(Axlsx::App), 'App object not created')
     assert(@package.instance_values["core"].is_a?(Axlsx::Core), 'Core object not created')
@@ -32,16 +38,16 @@ class TestPackage < Test::Unit::TestCase
     fname = 'axlsx_test_serialization.xlsx'
     assert_nothing_raised do
       begin
-         z= @package.serialize(@fname)              
+         z= @package.serialize(@fname)
          zf = Zip::ZipFile.open(@fname)
          @package.send(:parts).each{ |part| zf.get_entry(part[:entry]) }
-         File.delete(@fname)        
+         File.delete(@fname)
       rescue Errno::EACCES
          puts "WARNING:: test_serialization requires write access."
       end
-     end    
+     end
    end
-  
+
   def test_validation
     assert_equal(@package.validate.size, 0, @package.validate)
     #how to test for failure? the internal validations on the models are so strict I cant break anthing.....
@@ -51,7 +57,7 @@ class TestPackage < Test::Unit::TestCase
     p = @package.send(:parts)
     p.each do |part|
       #all parts must have :doc, :entry, :schema
-      assert(part.keys.size == 3 && part.keys.reject{ |k| [:doc, :entry, :schema].include? k}.empty?) 
+      assert(part.keys.size == 3 && part.keys.reject{ |k| [:doc, :entry, :schema].include? k}.empty?)
     end
     #all parts have an entry
     assert_equal(p.select{ |part| part[:entry] =~ /_rels\/\.rels/ }.size, 1, "rels missing")
@@ -71,8 +77,36 @@ class TestPackage < Test::Unit::TestCase
     assert_equal(p.size, 12)
 
   end
-  
+
+  def test_shared_strings_requires_part
+    @package.use_shared_strings = true
+    p = @package.send(:parts)
+    assert_equal(p.select{ |part| part[:entry] =~/xl\/sharedStrings.xml/}.size, 1, "shared strings table missing")
+  end
+
   def test_workbook_is_a_workbook
     assert @package.workbook.is_a? Axlsx::Workbook
   end
+
+  def test_base_content_types
+    ct = @package.send(:base_content_types)
+    assert(ct.select { |c| c.ContentType == Axlsx::RELS_CT }.size == 1, "rels content type missing")
+    assert(ct.select { |c| c.ContentType == Axlsx::XML_CT }.size == 1, "xml content type missing")
+    assert(ct.select { |c| c.ContentType == Axlsx::APP_CT }.size == 1, "app content type missing")
+    assert(ct.select { |c| c.ContentType == Axlsx::CORE_CT }.size == 1, "core content type missing")
+    assert(ct.select { |c| c.ContentType == Axlsx::STYLES_CT }.size == 1, "styles content type missing")
+    assert(ct.select { |c| c.ContentType == Axlsx::WORKBOOK_CT }.size == 1, "workbook content type missing")
+    assert(ct.size == 6)
+  end
+
+  def test_content_type_added_with_shared_strings
+    @package.use_shared_strings = true
+    ct = @package.send(:content_types)
+    assert(ct.select { |ct| ct.ContentType == Axlsx::SHARED_STRINGS_CT }.size == 1)
+  end
+
+  def test_name_to_indices
+    assert(Axlsx::name_to_indices('A1') == [0,0])
+    assert(Axlsx::name_to_indices('A100') == [0,99], 'needs to axcept rows that contain 0')
+  end
 end

data/test/util/tc_simple_typed_list.rb

@@ -1,11 +1,10 @@
-require 'test/unit'
-require 'axlsx.rb'
+require 'tc_helper.rb'
 class TestSimpleTypedList < Test::Unit::TestCase
-  def setup 
+  def setup
     @list = Axlsx::SimpleTypedList.new Fixnum
   end
 
-  def teardown 
+  def teardown
   end
 
   def test_type_is_a_class_or_array_of_class
@@ -15,18 +14,18 @@ class TestSimpleTypedList < Test::Unit::TestCase
     assert_raise(ArgumentError) { Axlsx::SimpleTypedList.new "1" }
     assert_raise(ArgumentError) { Axlsx::SimpleTypedList.new [Integer, "Class"] }
   end
-  
+
   def test_indexed_based_assignment
     #should not allow nil assignment
     assert_raise(ArgumentError) { @list[0] = nil }
     assert_raise(ArgumentError) { @list[0] = "1" }
     assert_nothing_raised { @list[0] = 1 }
   end
-  
+
   def test_concat_assignment
     assert_raise(ArgumentError) { @list << nil }
     assert_raise(ArgumentError) { @list << "1" }
-    assert_nothing_raised { @list << 1 }   
+    assert_nothing_raised { @list << 1 }
   end
 
   def test_concat_should_return_index
@@ -59,8 +58,8 @@ class TestSimpleTypedList < Test::Unit::TestCase
     assert_nothing_raised { @list.delete_at 3 }
     @list.unlock
     #ignore garbage
-    assert_nothing_raised { @list.delete 0 }   
-    assert_nothing_raised { @list.delete 9 }       
+    assert_nothing_raised { @list.delete 0 }
+    assert_nothing_raised { @list.delete 9 }
   end
 
 end

data/test/util/tc_validators.rb

@@ -1,30 +1,29 @@
-require 'test/unit'
-require 'axlsx.rb'
+require 'tc_helper.rb'
 class TestValidators < Test::Unit::TestCase
-  def setup    
+  def setup
   end
   def teardown
   end
-  
+
   def test_validators
     #unsigned_int
     assert_nothing_raised { Axlsx.validate_unsigned_int 1 }
     assert_nothing_raised { Axlsx.validate_unsigned_int +1 }
     assert_raise(ArgumentError) { Axlsx.validate_unsigned_int -1 }
     assert_raise(ArgumentError) { Axlsx.validate_unsigned_int '1' }
-    
+
     #int
     assert_nothing_raised { Axlsx.validate_int 1 }
     assert_nothing_raised { Axlsx.validate_int -1 }
     assert_raise(ArgumentError) { Axlsx.validate_int 'a' }
     assert_raise(ArgumentError) { Axlsx.validate_int Array }
- 
+
     #boolean (as 0 or 1, :true, :false, true, false, or "true," "false")
     [0,1,:true, :false, true, false, "true", "false"].each do |v|
       assert_nothing_raised { Axlsx.validate_boolean 0 }
     end
     assert_raise(ArgumentError) { Axlsx.validate_boolean 2 }
-    
+
     #string
     assert_nothing_raised { Axlsx.validate_string "1" }
     assert_raise(ArgumentError) { Axlsx.validate_string 2 }
@@ -64,7 +63,7 @@ class TestValidators < Test::Unit::TestCase
     assert_raise(ArgumentError) { Axlsx.validate_content_type nil }
     assert_raise(ArgumentError) { Axlsx.validate_content_type "http://some.url" }
     assert_raise(ArgumentError) { Axlsx.validate_content_type false }
- 
+
     #relationshipType
     assert_nothing_raised { Axlsx.validate_relationship_type Axlsx::WORKBOOK_R }
     assert_raise(ArgumentError) { Axlsx.validate_relationship_type nil }

data/test/workbook/tc_shared_strings_table.rb

@@ -0,0 +1,38 @@
+require 'tc_helper.rb'
+
+class TestSharedStringsTable < Test::Unit::TestCase
+
+  def setup
+    @p = Axlsx::Package.new :use_shared_strings=>true
+    ws = @p.workbook.add_worksheet
+    ws.add_row ['a', 1, 'b']
+    ws.add_row ['b', 1, 'c']
+    ws.add_row ['c', 1, 'd']
+  end
+
+  def test_workbook_has_shared_strings
+    assert(@p.workbook.shared_strings.is_a?(Axlsx::SharedStringsTable), "shared string table was not created")
+  end
+
+  def test_count
+    sst = @p.workbook.shared_strings
+    assert_equal(sst.count, 6)
+  end
+
+  def test_unique_count
+    sst = @p.workbook.shared_strings
+    assert_equal(sst.unique_count, 4)
+  end
+
+  def test_valid_document
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    doc = Nokogiri::XML(@p.workbook.shared_strings.to_xml_string)
+    errors = []
+    schema.validate(doc).each do |error|
+      puts error.message
+      errors << error
+    end
+    assert_equal(errors.size, 0, "sharedStirngs.xml Invalid" + errors.map{ |e| e.message }.to_s)
+  end
+
+end

data/test/workbook/tc_workbook.rb

@@ -1,15 +1,21 @@
-require 'test/unit'
-require 'axlsx.rb'
+require 'tc_helper.rb'
 
 class TestWorkbook < Test::Unit::TestCase
-  def setup    
+  def setup
     p = Axlsx::Package.new
-    @wb = p.workbook    
+    @wb = p.workbook
   end
 
   def teardown
   end
 
+  def test_no_autowidth
+    assert_equal(@wb.use_autowidth, true)
+    assert_raise(ArgumentError) {@wb.use_autowidth = 0.1}
+    assert_nothing_raised {@wb.use_autowidth = false}
+    assert_equal(@wb.use_autowidth, false)
+  end
+
   def test_date1904
     assert_equal(Axlsx::Workbook.date1904, @wb.date1904)
     @wb.date1904 = :false
@@ -18,6 +24,14 @@ class TestWorkbook < Test::Unit::TestCase
     assert_equal(Axlsx::Workbook.date1904, @wb.date1904)
   end
 
+
+
+  def test_shared_strings
+    assert_equal(@wb.use_shared_strings, nil)
+    assert_raise(ArgumentError) {@wb.use_shared_strings = 'bpb'}
+    assert_nothing_raised {@wb.use_shared_strings = :true}
+  end
+
   def test_add_worksheet
     assert(@wb.worksheets.empty?, "worbook has no worksheets by default")
     ws = @wb.add_worksheet(:name=>"bob")
@@ -30,11 +44,13 @@ class TestWorkbook < Test::Unit::TestCase
     assert(@wb.relationships.size == 1)
     @wb.add_worksheet
     assert(@wb.relationships.size == 2)
+    @wb.use_shared_strings = true
+    assert(@wb.relationships.size == 3)
   end
 
   def test_to_xml
     schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
-    doc = Nokogiri::XML(@wb.to_xml)
+    doc = Nokogiri::XML(@wb.to_xml_string)
     errors = []
     schema.validate(doc).each do |error|
       errors.push error
@@ -52,9 +68,19 @@ class TestWorkbook < Test::Unit::TestCase
 
   def test_to_xml_adds_worksheet_when_worksheets_is_empty
     assert(@wb.worksheets.empty?)
-    @wb.to_xml
+    @wb.to_xml_string
     assert(@wb.worksheets.size == 1)
   end
 
 
+  def test_to_xml_string_defined_names
+    @wb.add_worksheet do |sheet|
+      sheet.add_row [1, "two"]
+      sheet.auto_filter = "A1:B1"
+    end
+    doc = Nokogiri::XML(@wb.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:workbook/xmlns:definedNames/xmlns:definedName').inner_text, @wb.worksheets[0].abs_auto_filter)
+  end
+
+
 end

data/test/workbook/worksheet/table/tc_table.rb

@@ -0,0 +1,71 @@
+require 'tc_helper.rb'
+
+class TestTable < Test::Unit::TestCase
+  def setup
+    p = Axlsx::Package.new
+    @ws = p.workbook.add_worksheet
+    40.times do
+      @ws << ["aa","aa","aa","aa","aa","aa"]
+    end
+  end
+
+  def test_initialization
+    assert(@ws.workbook.tables.empty?)
+    assert(@ws.tables.empty?)
+
+  end
+
+  def test_add_table
+    name = "test"
+    table = @ws.add_table("A1:D5", :name => name)
+    assert(table.is_a?(Axlsx::Table), "must create a table")
+    assert_equal(@ws.workbook.tables.last, table, "must be added to workbook table collection")
+    assert_equal(@ws.tables.last, table, "must be added to worksheet table collection")
+    assert_equal(table.name, name, "options for name are applied")
+
+  end
+
+  def test_charts
+    assert(@ws.drawing.charts.empty?)
+    chart = @ws.add_chart(Axlsx::Pie3DChart, :title=>"bob", :start_at=>[0,0], :end_at=>[1,1])
+    assert_equal(@ws.drawing.charts.last, chart, "add chart is returned")
+    chart = @ws.add_chart(Axlsx::Pie3DChart, :title=>"nancy", :start_at=>[1,5], :end_at=>[5,10])
+    assert_equal(@ws.drawing.charts.last, chart, "add chart is returned")
+  end
+
+  def test_pn
+    table = @ws.add_table("A1:D5")
+    assert_equal(@ws.tables.first.pn, "tables/table1.xml")
+  end
+
+  def test_rId
+    table = @ws.add_table("A1:D5")
+    assert_equal(@ws.tables.first.rId, "rId1")
+  end
+
+  def test_index
+    table = @ws.add_table("A1:D5")
+    assert_equal(@ws.tables.first.index, @ws.workbook.tables.index(@ws.tables.first))
+  end
+
+  def test_relationships
+    assert(@ws.relationships.empty?)
+    table = @ws.add_table("A1:D5")
+    assert_equal(@ws.relationships.size, 1, "adding a table adds a relationship")
+    table = @ws.add_table("F1:J5")
+    assert_equal(@ws.relationships.size, 2, "adding a table adds a relationship")
+  end
+
+  def test_to_xml_string
+    table = @ws.add_table("A1:D5")
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    doc = Nokogiri::XML(table.to_xml_string)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors.push error
+      puts error.message
+    end
+    assert(errors.empty?, "error free validation")
+  end
+
+end

data/test/workbook/worksheet/table/tc_table.rb~

@@ -0,0 +1,72 @@
+require 'test/unit'
+require 'tc_helper.rb'
+
+class TestTable < Test::Unit::TestCase
+  def setup    
+    p = Axlsx::Package.new
+    @ws = p.workbook.add_worksheet
+    40.times do 
+      @ws << ["aa","aa","aa","aa","aa","aa"]
+    end
+  end
+
+  def test_initialization
+    assert(@ws.workbook.tables.empty?)
+    assert(@ws.tables.empty?)
+    
+  end
+
+  def test_add_table
+    name = "test"
+    table = @ws.add_table("A1:D5", :name => name)
+    assert(table.is_a?(Axlsx::Table), "must create a table")
+    assert_equal(@ws.workbook.tables.last, table, "must be added to workbook table collection")
+    assert_equal(@ws.tables.last, table, "must be added to worksheet table collection")
+    assert_equal(table.name, name, "options for name are applied")
+
+  end
+ 
+  def test_charts
+    assert(@ws.drawing.charts.empty?)
+    chart = @ws.add_chart(Axlsx::Pie3DChart, :title=>"bob", :start_at=>[0,0], :end_at=>[1,1])
+    assert_equal(@ws.drawing.charts.last, chart, "add chart is returned")
+    chart = @ws.add_chart(Axlsx::Pie3DChart, :title=>"nancy", :start_at=>[1,5], :end_at=>[5,10])
+    assert_equal(@ws.drawing.charts.last, chart, "add chart is returned")   
+  end
+
+  def test_pn
+    table = @ws.add_table("A1:D5")
+    assert_equal(@ws.tables.first.pn, "tables/table1.xml")
+  end
+
+  def test_rId
+    table = @ws.add_table("A1:D5")
+    assert_equal(@ws.tables.first.rId, "rId1")
+  end
+  
+  def test_index
+    table = @ws.add_table("A1:D5")
+    assert_equal(@ws.tables.first.index, @ws.workbook.tables.index(@ws.tables.first))
+  end
+
+  def test_relationships
+    assert(@ws.relationships.empty?)
+    table = @ws.add_table("A1:D5")
+    assert_equal(@ws.relationships.size, 1, "adding a table adds a relationship")
+    table = @ws.add_table("F1:J5")
+    assert_equal(@ws.relationships.size, 2, "adding a table adds a relationship")
+  end
+
+  def test_to_xml
+    table = @ws.add_table("A1:D5")
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    doc = Nokogiri::XML(table.to_xml)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors.push error
+      puts error.message
+    end
+    assert(errors.empty?, "error free validation")
+  end
+
+end

data/test/workbook/worksheet/tc_cell.rb

@@ -1,5 +1,4 @@
-require 'test/unit'
-require 'axlsx.rb'
+require 'tc_helper.rb'
 
 class TestCell < Test::Unit::TestCase
 
@@ -9,8 +8,11 @@ class TestCell < Test::Unit::TestCase
     p.workbook.styles.add_style :sz=>20
     @row = @ws.add_row
     @c = @row.add_cell 1, :type=>:float, :style=>1
+    data = (0..26).map { |index| index }
+    @ws.add_row data
+    @cAA = @ws["AA2"]
   end
-  
+
   def test_initialize
     assert_equal(@row.cells.last, @c, "the cell was added to the row")
     assert_equal(@c.type, :float, "type option is applied")
@@ -23,6 +25,10 @@ class TestCell < Test::Unit::TestCase
     assert_equal(Axlsx::STYLE_DATE, c.style)
   end
 
+  def test_row
+    assert_equal(@c.row, @row)
+  end
+
   def test_index
     assert_equal(@c.index, @row.cells.index(@c))
   end
@@ -35,45 +41,56 @@ class TestCell < Test::Unit::TestCase
     assert_equal(@c.r, "A1", "calculate cell reference")
   end
 
+  def test_wide_r
+      assert_equal(@cAA.r, "AA2", "calculate cell reference")
+  end
+
   def test_r_abs
     assert_equal(@c.r_abs,"$A$1", "calculate absolute cell reference")
+    assert_equal(@cAA.r_abs,"$AA$2", "needs to accept multi-digit columns")
   end
 
   def test_style
     assert_raise(ArgumentError, "must reject invalid style indexes") { @c.style=@c.row.worksheet.workbook.styles.cellXfs.size }
-    assert_nothing_raised("must allow valid style index changes") {@c.style=1} 
+    assert_nothing_raised("must allow valid style index changes") {@c.style=1}
     assert_equal(@c.style, 1)
   end
 
   def test_type
-    assert_raise(ArgumentError, "type must be :string, :integer, :float, :time") { @c.type = :array }
+    assert_raise(ArgumentError, "type must be :string, :integer, :float, :date, :time, :boolean") { @c.type = :array }
     assert_nothing_raised("type can be changed") { @c.type = :string }
     assert_equal(@c.value, "1.0", "changing type casts the value")
-    
+
     assert_equal(@row.add_cell(Time.now).type, :time, 'time should be time')
+    assert_equal(@row.add_cell(Date.today).type, :date, 'date should be date')
+    assert_equal(@row.add_cell(true).type, :boolean, 'boolean should be boolean')
   end
 
   def test_value
-    assert_raise(ArgumentError, "type must be :string, :integer, :float, :time") { @c.type = :array }
+    assert_raise(ArgumentError, "type must be :string, :integer, :float, :date, :time, :boolean") { @c.type = :array }
     assert_nothing_raised("type can be changed") { @c.type = :string }
     assert_equal(@c.value, "1.0", "changing type casts the value")
   end
 
   def test_col_ref
-    assert_equal(@c.send(:col_ref), "A")
+    #TODO move to axlsx spec
+    assert_equal(Axlsx.col_ref(0), "A")
   end
 
   def test_cell_type_from_value
     assert_equal(@c.send(:cell_type_from_value, 1.0), :float)
     assert_equal(@c.send(:cell_type_from_value, 1), :integer)
+    assert_equal(@c.send(:cell_type_from_value, Date.today), :date)
     assert_equal(@c.send(:cell_type_from_value, Time.now), :time)
     assert_equal(@c.send(:cell_type_from_value, []), :string)
     assert_equal(@c.send(:cell_type_from_value, "d"), :string)
     assert_equal(@c.send(:cell_type_from_value, nil), :string)
     assert_equal(@c.send(:cell_type_from_value, -1), :integer)
+    assert_equal(@c.send(:cell_type_from_value, true), :boolean)
+    assert_equal(@c.send(:cell_type_from_value, false), :boolean)
   end
 
-  def test_cast_value    
+  def test_cast_value
     @c.type = :string
     assert_equal(@c.send(:cast_value, 1.0), "1.0")
     @c.type = :integer
@@ -81,8 +98,12 @@ class TestCell < Test::Unit::TestCase
     @c.type = :float
     assert_equal(@c.send(:cast_value, "1.0"), 1.0)
     @c.type = :string
-    assert_equal(@c.send(:cast_value, nil), "")
-
+    assert_equal(@c.send(:cast_value, nil), nil)
+    @c.type = :float
+    assert_equal(@c.send(:cast_value, nil), nil)
+    @c.type = :boolean
+    assert_equal(@c.send(:cast_value, true), 1)
+    assert_equal(@c.send(:cast_value, false), 0)
   end
 
   def test_color
@@ -180,7 +201,7 @@ class TestCell < Test::Unit::TestCase
     @c.row.add_cell 2
     @c.row.add_cell 3
     @c.merge "A2"
-    assert_equal(@c.row.worksheet.merged_cells.last, "A1:A2")    
+    assert_equal(@c.row.worksheet.merged_cells.last, "A1:A2")
   end
 
   def test_merge_with_cell
@@ -188,7 +209,53 @@ class TestCell < Test::Unit::TestCase
     @c.row.add_cell 2
     @c.row.add_cell 3
     @c.merge @row.cells.last
-    assert_equal(@c.row.worksheet.merged_cells.last, "A1:C1")    
+    assert_equal(@c.row.worksheet.merged_cells.last, "A1:C1")
+  end
+
+  def test_ssti
+    assert_raise(ArgumentError, "ssti must be an unsigned integer!") { @c.send(:ssti=, -1) }
+    @c.send :ssti=, 1
+    assert_equal(@c.ssti, 1)
+  end
+
+  def test_plain_string
+    @c.type = :integer
+    assert_equal(@c.plain_string?, false)
+
+    @c.type = :string
+    @c.value = 'plain string'
+    assert_equal(@c.plain_string?, true)
+
+    @c.value = nil
+    assert_equal(@c.plain_string?, false)
+
+    @c.value = ''
+    assert_equal(@c.plain_string?, false)
+
+    @c.value = '=sum'
+    assert_equal(@c.plain_string?, false)
+
+    @c.value = 'plain string'
+    @c.font_name = 'Arial'
+    assert_equal(@c.plain_string?, false)
+  end
+
+  def test_to_xml_string
+    c_xml = Nokogiri::XML(@c.to_xml_string(1,1))
+    assert_equal(c_xml.xpath("/c[@s=1]").size, 1)
+  end
+  def test_to_xml
+    # TODO This could use some much more stringent testing related to the xml content generated!
+    row = @ws.add_row [Time.now, Date.today, true, 1, 1.0, "text", "=sum(A1:A2)"]
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    errors = []
+    schema.validate(doc).each do |error|
+      errors.push error
+      puts error.message
+    end
+    assert(errors.empty?, "error free validation")
+
   end
 
 end

data/test/workbook/worksheet/tc_col.rb

@@ -0,0 +1,59 @@
+require 'tc_helper.rb'
+
+class TestCol < Test::Unit::TestCase
+
+  def setup
+    @col = Axlsx::Col.new 1, 1
+  end
+
+  def test_min_max_required
+    assert_raise(ArgumentError, 'min and max must be specified when creating a new column') { Axlsx::Col.new }
+    assert_raise(ArgumentError, 'min and max must be specified when creating a new column') { Axlsx::Col.new nil, nil }
+    assert_nothing_raised { Axlsx::Col.new 1, 1 }
+  end
+
+  def test_bestFit
+    assert_equal(@col.bestFit, nil)
+    assert_raise(NoMethodError, 'bestFit is read only') { @col.bestFit = 'bob' }
+    @col.width = 1.999
+    assert_equal(@col.bestFit, true, 'bestFit should be true when width has been set')
+  end
+
+  def test_collapsed
+    assert_equal(@col.collapsed, nil)
+    assert_raise(ArgumentError, 'collapsed must be boolean(ish)') { @col.collapsed = 'bob' }
+    assert_nothing_raised('collapsed must be boolean(ish)') { @col.collapsed = true }
+  end
+
+  def test_customWidth
+    assert_equal(@col.customWidth, nil)
+    @col.width = 3
+    assert_raise(NoMethodError, 'customWidth is read only') { @col.customWidth = 3 }
+    assert_equal(@col.customWidth, true, 'customWidth is true when width is set')
+  end
+
+  def test_hidden
+    assert_equal(@col.hidden, nil)
+    assert_raise(ArgumentError, 'hidden must be boolean(ish)') { @col.hidden = 'bob' }
+    assert_nothing_raised(ArgumentError, 'hidden must be boolean(ish)') { @col.hidden = true }
+  end
+
+  def test_outlineLevel
+    assert_equal(@col.outlineLevel, nil)
+    assert_raise(ArgumentError, 'outline level cannot be negative') { @col.outlineLevel = -1 }
+    assert_raise(ArgumentError, 'outline level cannot be greater than 7') { @col.outlineLevel = 8 }
+    assert_nothing_raised('can set outlineLevel') { @col.outlineLevel = 1 }
+  end
+
+  def test_phonetic
+    assert_equal(@col.phonetic, nil)
+    assert_raise(ArgumentError, 'phonetic must be boolean(ish)') { @col.phonetic = 'bob' }
+    assert_nothing_raised(ArgumentError, 'phonetic must be boolean(ish)') { @col.phonetic = true }
+  end
+
+  def test_style
+    assert_equal(@col.style, nil)
+    #TODO check that the style specified is actually in the styles xfs collection
+  end
+
+end

data/test/workbook/worksheet/tc_col.rb~

@@ -0,0 +1,10 @@
+require 'tc_helper.rb'
+
+class TestCol < Test::Unit::TestCase
+
+  def setup
+
+  end
+
+
+end