axlsx 1.0.16 → 1.1.0

data/test/workbook/worksheet/tc_date_time_converter.rb

@@ -0,0 +1,126 @@
+# -*- 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 = begin
+      Time.new 2012, 1, 1, 1, 0, 0, 3600 # January 1st, 2012 at 1:00 GMT+1
+    rescue ArgumentError
+      Time.parse "2012-01-01 01:00:00 +0100"
+    end
+    assert_equal local, utc
+    assert_equal Axlsx::DateTimeConverter::time_to_serial(local), Axlsx::DateTimeConverter::time_to_serial(utc)
+    Axlsx::Workbook.date1904 = true
+    assert_equal Axlsx::DateTimeConverter::time_to_serial(local), Axlsx::DateTimeConverter::time_to_serial(utc)
+  end
+
+end

data/test/workbook/worksheet/tc_page_margins.rb

@@ -0,0 +1,97 @@
+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_row.rb

@@ -1,5 +1,4 @@
-require 'test/unit'
-require 'axlsx.rb'
+require 'tc_helper.rb'
 
 class TestRow < Test::Unit::TestCase
 
@@ -8,16 +7,37 @@ class TestRow < Test::Unit::TestCase
     @ws = p.workbook.add_worksheet :name=>"hmmm"
     @row = @ws.add_row
   end
-  
+
   def test_initialize
     assert(@row.cells.empty?, "no cells by default")
     assert_equal(@row.worksheet, @ws, "has a reference to the worksheet")
+    assert_nil(@row.height, "height defaults to nil")
+    assert(!@row.custom_height?, "no custom height by default")
+  end
+
+  def test_initialize_with_fixed_height
+    row = @ws.add_row([1,2,3,4,5], :height=>40)
+    assert_equal(40, row.height)
+    assert(row.custom_height?)
   end
 
   def test_style
     r = @ws.add_row([1,2,3,4,5])
     r.style=1
-    r.cells.each { |c| assert_equal(c.style,1) }    
+    r.cells.each { |c| assert_equal(c.style,1) }
+  end
+
+  def test_nil_cells
+    row = @ws.add_row([nil,1,2,nil,4,5,nil])
+    r_s_xml = Nokogiri::XML(row.to_xml_string(0, ''))
+    assert_equal(r_s_xml.xpath(".//row/c").size, 4)
+  end
+  
+  def test_nil_cell_r
+    row = @ws.add_row([nil,1,2,nil,4,5,nil])
+    r_s_xml = Nokogiri::XML(row.to_xml_string(0, ''))
+    assert_equal(r_s_xml.xpath(".//row/c").first['r'], 'B1')
+    assert_equal(r_s_xml.xpath(".//row/c").last['r'], 'F1')
   end
 
   def test_index
@@ -33,4 +53,34 @@ class TestRow < Test::Unit::TestCase
     r = @ws.add_row [1,2,3], :style=>0, :types=>:integer
     assert_equal(r.cells.size, 3)
   end
+
+  def test_custom_height
+    @row.height = 20
+    assert(@row.custom_height?)
+  end
+
+  def test_height
+    assert_raise(ArgumentError) { @row.height = -3 }
+    assert_nothing_raised { @row.height = 15 }
+    assert_equal(15, @row.height)
+  end
+
+  def test_to_xml_without_custom_height
+    doc = Nokogiri::XML.parse(@row.to_xml_string(0))
+    assert_equal(0, doc.xpath(".//row[@ht]").size)
+    assert_equal(0, doc.xpath(".//row[@customHeight]").size)
+  end
+
+  def test_to_xml_string
+    r_s_xml = Nokogiri::XML(@row.to_xml_string(0, ''))
+    assert_equal(r_s_xml.xpath(".//row[@r=1]").size, 1)
+  end
+
+  def test_to_xml_string_with_custom_height
+    @row.add_cell 1
+    @row.height = 20
+    r_s_xml = Nokogiri::XML(@row.to_xml_string(0, ''))
+    assert_equal(r_s_xml.xpath(".//row[@r=1][@ht=20][@customHeight=1]").size, 1)
+  end
+
 end

data/test/workbook/worksheet/tc_worksheet.rb

@@ -1,18 +1,63 @@
-require 'test/unit'
-require 'axlsx.rb'
+require 'tc_helper.rb'
 
 class TestWorksheet < Test::Unit::TestCase
-  def setup    
-    p = Axlsx::Package.new
-    @ws = p.workbook.add_worksheet
+  def setup
+    @p = Axlsx::Package.new
+    @wb = @p.workbook
+    @ws = @wb.add_worksheet
   end
 
+
   def test_pn
     assert_equal(@ws.pn, "worksheets/sheet1.xml")
     ws = @ws.workbook.add_worksheet
     assert_equal(ws.pn, "worksheets/sheet2.xml")
   end
 
+  def test_page_margins
+    assert(@ws.page_margins.is_a? Axlsx::PageMargins)
+  end
+
+  def test_page_margins_yeild
+    @ws.page_margins do |pm|
+      assert(pm.is_a? Axlsx::PageMargins)
+      assert(@ws.page_margins == pm)
+    end
+  end
+
+  def test_no_autowidth
+    @ws.workbook.use_autowidth = false
+    @ws.add_row [1,2,3,4]
+    assert_equal(@ws.column_info[0].width, nil)
+  end
+
+  def test_initialization_options
+    page_margins = {:left => 2, :right => 2, :bottom => 2, :top => 2, :header => 2, :footer => 2}
+    optioned = @ws.workbook.add_worksheet(:name => 'bob', :page_margins => page_margins, :selected => true, :show_gridlines => false)
+    assert_equal(optioned.page_margins.left, page_margins[:left])
+    assert_equal(optioned.page_margins.right, page_margins[:right])
+    assert_equal(optioned.page_margins.top, page_margins[:top])
+    assert_equal(optioned.page_margins.bottom, page_margins[:bottom])
+    assert_equal(optioned.page_margins.header, page_margins[:header])
+    assert_equal(optioned.page_margins.footer, page_margins[:footer])
+    assert_equal(optioned.name, 'bob')
+    assert_equal(optioned.selected, true)
+    assert_equal(optioned.show_gridlines, false)
+  end
+
+
+  def test_use_gridlines
+    assert_raise(ArgumentError) { @ws.show_gridlines = -1.1 }
+    assert_nothing_raised { @ws.show_gridlines = false }
+    assert_equal(@ws.show_gridlines, false)
+  end
+
+  def test_selected
+    assert_raise(ArgumentError) { @ws.selected = -1.1 }
+    assert_nothing_raised { @ws.selected = true }
+    assert_equal(@ws.selected, true)
+  end
+
   def test_rels_pn
     assert_equal(@ws.rels_pn, "worksheets/_rels/sheet1.xml.rels")
     ws = @ws.workbook.add_worksheet
@@ -24,18 +69,28 @@ class TestWorksheet < Test::Unit::TestCase
     ws = @ws.workbook.add_worksheet
     assert_equal(ws.rId, "rId2")
   end
-  
+
   def test_index
     assert_equal(@ws.index, @ws.workbook.worksheets.index(@ws))
   end
-  
+
+  def test_dimension
+    @ws.add_row [1, 2, 3]
+    @ws.add_row [4, 5, 6]
+    assert_equal @ws.dimension, "A1:C2"
+  end
+
   def test_referencing
     @ws.add_row [1, 2, 3]
     @ws.add_row [4, 5, 6]
     range = @ws["A1:C2"]
+    first_row = @ws[0]
+    last_row = @ws[1]
+    assert_equal(@ws.rows[0],first_row)
+    assert_equal(@ws.rows[1],last_row)
     assert_equal(range.size, 6)
     assert_equal(range.first, @ws.rows.first.cells.first)
-    assert_equal(range.last, @ws.rows.last.cells.last)    
+    assert_equal(range.last, @ws.rows.last.cells.last)
   end
 
   def test_add_row
@@ -61,7 +116,7 @@ class TestWorksheet < Test::Unit::TestCase
     @ws.add_row [1,2,3,4]
     @ws.add_row [1,2,3,4]
     @ws.col_style( (1..2), 1, :row_offset=>1)
-    @ws.rows[(1..-1)].each do | r | 
+    @ws.rows[(1..-1)].each do | r |
       assert_equal(r.cells[1].style, 1)
       assert_equal(r.cells[2].style, 1)
     end
@@ -82,7 +137,7 @@ class TestWorksheet < Test::Unit::TestCase
     @ws.add_row [1,2,3,4]
     @ws.add_row [1,2,3,4]
     c = @ws.cols[1]
-    assert_equal(c.size, 4)    
+    assert_equal(c.size, 4)
     assert_equal(c[0].value, 2)
   end
 
@@ -92,16 +147,103 @@ class TestWorksheet < Test::Unit::TestCase
     @ws.add_row [1,2,3,4]
     @ws.add_row [1,2,3,4]
     @ws.row_style 1, 1, :col_offset=>1
-    @ws.rows[1].cells[(1..-1)].each do | c | 
+    @ws.rows[1].cells[(1..-1)].each do | c |
       assert_equal(c.style, 1)
     end
     assert_equal(@ws.rows[1].cells[0].style, 0)
     assert_equal(@ws.rows[2].cells[1].style, 0)
   end
-  
-  def test_to_xml
+
+  def test_to_xml_string_fit_to_page
+    @ws.fit_to_page = true
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:sheetPr/xmlns:pageSetUpPr[@fitToPage="true"]').size, 1)
+  end
+
+  def test_to_xml_string_dimensions
+    @ws.add_row [1,2,3]
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:dimension[@ref="A1:C1"]').size, 1)
+  end
+
+  def test_to_xml_string_selected
+    @ws.selected = true
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:sheetViews/xmlns:sheetView[@tabSelected="true"]').size, 1)
+  end
+
+  def test_to_xml_string_show_gridlines
+    @ws.show_gridlines = false
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:sheetViews/xmlns:sheetView[@showGridLines="false"]').size, 1)
+  end
+
+
+  def test_to_xml_string_show_selection
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:sheetViews/xmlns:sheetView/xmlns:selection[@activeCell="A1"]').size, 1)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:sheetViews/xmlns:sheetView/xmlns:selection[@sqref="A1"]').size, 1)
+  end
+
+  def test_to_xml_string_auto_fit_data
+    @ws.add_row [1, "two"]
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:cols/xmlns:col').size, 2)
+  end
+
+  def test_to_xml_string_sheet_data
+    @ws.add_row [1, "two"]
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:sheetData/xmlns:row').size, 1)
+  end
+
+  def test_to_xml_string_auto_filter
+    @ws.add_row [1, "two"]
+    @ws.auto_filter = "A1:B1"
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:autoFilter[@ref="A1:B1"]').size, 1)
+  end
+
+  def test_to_xml_string_merge_cells
+    @ws.add_row [1, "two"]
+    @ws.merge_cells "A1:D1"
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:mergeCells/xmlns:mergeCell[@ref="A1:D1"]').size, 1)
+  end
+
+  def test_to_xml_string_page_margins
+    @ws.page_margins do |pm|
+      pm.left = 9
+      pm.right = 7
+    end
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:pageMargins[@left="9"][@right="7"]').size, 1)
+  end
+
+  def test_to_xml_string_drawing
+    c = @ws.add_chart Axlsx::Pie3DChart
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:drawing[@r:id="rId1"]').size, 1)
+  end
+
+  def test_to_xml_string_tables
+    @ws.add_row ["one", "two"]
+    @ws.add_row [1, 2]
+    @ws.add_table "A1:B2"
+    doc = Nokogiri::XML(@ws.to_xml_string)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:tableParts[@count="1"]').size, 1)
+    assert_equal(doc.xpath('//xmlns:worksheet/xmlns:tableParts/xmlns:tablePart[@r:id="rId1"]').size, 1)
+  end
+
+  def test_abs_auto_filter
+    @ws.add_row [1, "two", 3]
+    @ws.auto_filter = "A1:C1"
+    assert_equal(@ws.abs_auto_filter, "'Sheet1'!$A$1:$C$1")
+  end
+
+  def test_to_xml_string
     schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
-    doc = Nokogiri::XML(@ws.to_xml)
+    doc = Nokogiri::XML(@ws.to_xml_string)
     errors = []
     schema.validate(doc).each do |error|
       errors.push error
@@ -110,6 +252,19 @@ class TestWorksheet < Test::Unit::TestCase
     assert(errors.empty?, "error free validation")
   end
 
+  def test_valid_with_page_margins
+    @ws.page_margins.set :left => 9
+    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
+
   def test_relationships
     assert(@ws.relationships.empty?, "No Drawing relationship until you add a chart")
     c = @ws.add_chart Axlsx::Pie3DChart
@@ -118,35 +273,40 @@ class TestWorksheet < Test::Unit::TestCase
     assert_equal(@ws.relationships.size, 1, "multiple charts still only result in one relationship")
   end
 
-  
+
   def test_name_unique
     assert_raise(ArgumentError, "worksheet name must be unique") { n = @ws.name; @ws.workbook.add_worksheet(:name=> @ws) }
   end
 
-  def test_update_auto_with_data
-    small = @ws.workbook.styles.add_style(:sz=>2)
-    big = @ws.workbook.styles.add_style(:sz=>10)
-
-    @ws.add_row ["chasing windmills", "penut"], :style=>small
-    assert(@ws.auto_fit_data.size == 2, "a data item for each column")
-
-    assert_equal(@ws.auto_fit_data[0], {:sz=>2,:longest=>"chasing windmills"}, "adding a row updates auto_fit_data if the product of the string length and font is greater for the column")
-
-
-    @ws.add_row ["mule"], :style=>big
-    assert_equal(@ws.auto_fit_data[0], {:sz=>10,:longest=>"mule"}, "adding a row updates auto_fit_data if the product of the string length and font is greater for the column")
+  def test_name_size
+    assert_raise(ArgumentError, "name too long!") { @ws.name = Array.new(32, "A").join('') }
+    assert_nothing_raised { @ws.name = Array.new(31, "A").join('') }
   end
 
-  def test_auto_width
-    assert(@ws.send(:auto_width, {:sz=>11, :longest=>"fisheries"}) > @ws.send(:auto_width, {:sz=>11, :longest=>"fish"}), "longer strings get a longer auto_width at the same font size")
+  def test_set_fixed_width_column
+    @ws.add_row ["mule", "donkey", "horse"], :widths => [20, :ignore, nil]
+    assert(@ws.column_info.size == 3, "a data item for each column")
+    assert_equal(@ws.column_info[0].width, 20, "adding a row with fixed width updates :fixed attribute")
+    assert_equal(@ws.column_info[1].width, nil, ":ignore does not set any data")
+  end
 
-    assert(@ws.send(:auto_width, {:sz=>11, :longest=>"fish"}) < @ws.send(:auto_width, {:sz=>12, :longest=>"fish"}), "larger fonts produce longer with with same string")
+  def test_fixed_height
+    @ws.add_row [1, 2, 3], :height => 40
+    assert_equal(40, @ws.rows[-1].height)
+  end
 
+  def test_set_column_width
+    @ws.add_row ["chasing windmills", "penut"]
+    @ws.column_widths nil, 0.5
+    assert_equal(@ws.column_info[1].width, 0.5, 'eat my width')
+    assert_raise(ArgumentError, 'reject invalid columns') { @ws.column_widths 2, 7, nil }
+    assert_raise(ArgumentError, 'only accept unsigned ints') { @ws.column_widths 2, 7, -1 }
+    assert_raise(ArgumentError, 'only accept Integer, Float or Fixnum') { @ws.column_widths 2, 7, "-1" }
   end
 
   def test_merge_cells
     assert(@ws.merged_cells.is_a?(Array))
-    assert_equal(@ws.merged_cells.size, 0)           
+    assert_equal(@ws.merged_cells.size, 0)
     @ws.add_row [1,2,3]
     @ws.add_row [4,5,6]
     @ws.add_row [7,8,9]