caxlsx 3.0.2 → 3.1.1

data/lib/axlsx/workbook/worksheet/table.rb

@@ -80,7 +80,7 @@ module Axlsx
       str << ('<autoFilter ref="' << @ref << '"/>')
       str << ('<tableColumns count="' << header_cells.length.to_s << '">')
       header_cells.each_with_index do |cell,index|
-        str << ('<tableColumn id ="' << (index+1).to_s << '" name="' << cell.value << '"/>')
+        str << ('<tableColumn id ="' << (index+1).to_s << '" name="' << cell.clean_value << '"/>')
       end
       str << '</tableColumns>'
       table_style_info.to_xml_string(str)

data/lib/axlsx/workbook/worksheet/worksheet.rb

@@ -393,6 +393,9 @@ module Axlsx
     # @example - specify whether a certain cells in a row should escape formulas or not
     #     ws.add_row ['=IF(2+2=4,4,5)', '=IF(13+13=4,4,5)'], :escape_formulas=>[true, false]
     #
+    # @example - add a column offset when adding a row (inserts 'n' blank, unstyled columns before data)
+    #     ws.add_row ['I wish', 'for a fish', 'on my fish wish dish'], offset: 3
+    #
     # @see Worksheet#column_widths
     # @return [Row]
     # @option options [Array] values
@@ -400,6 +403,7 @@ module Axlsx
     # @option options [Array, Integer] style
     # @option options [Array] widths each member of the widths array will affect how auto_fit behavies.
     # @option options [Float] height the row's height (in points)
+    # @option options [Integer] offset - add empty columns before values
     # @option options [Array, Boolean] escape_formulas - Whether to treat a value starting with an equal
     #    sign as formula (default) or as simple string.
     #    Allowing user generated data to be interpreted as formulas can be dangerous
@@ -663,7 +667,9 @@ module Axlsx
 
     def validate_sheet_name(name)
       DataTypeValidator.validate :worksheet_name, String, name
-      raise ArgumentError, (ERR_SHEET_NAME_TOO_LONG % name) if name.bytesize > 31
+      # ignore first character (BOM) after encoding to utf16 because Excel does so, too.
+      character_length = name.encode("utf-16")[1..-1].encode("utf-16").bytesize / 2
+      raise ArgumentError, (ERR_SHEET_NAME_TOO_LONG % name) if character_length > 31
       raise ArgumentError, (ERR_SHEET_NAME_CHARACTER_FORBIDDEN % name) if '[]*/\?:'.chars.any? { |char| name.include? char }
       name = Axlsx::coder.encode(name)
       sheet_names = @workbook.worksheets.reject { |s| s == self }.map { |s| s.name }

data/lib/axlsx.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 require 'htmlentities'
 require 'axlsx/version.rb'
-require 'mimemagic'
+require 'marcel'
 
 require 'axlsx/util/simple_typed_list.rb'
 require 'axlsx/util/constants.rb'
@@ -10,6 +10,7 @@ require 'axlsx/util/accessors.rb'
 require 'axlsx/util/serialized_attributes'
 require 'axlsx/util/options_parser'
 require 'axlsx/util/mime_type_utils'
+require 'axlsx/util/zip_command'
 
 require 'axlsx/stylesheet/styles.rb'
 
@@ -50,10 +51,11 @@ module Axlsx
   # determines the cell range for the items provided
   def self.cell_range(cells, absolute=true)
     return "" unless cells.first.is_a? Cell
-    cells = sort_cells(cells)
-    reference = "#{cells.first.reference(absolute)}:#{cells.last.reference(absolute)}"
+
+    first_cell, last_cell = cells.minmax_by(&:pos)
+    reference = "#{first_cell.reference(absolute)}:#{last_cell.reference(absolute)}"
     if absolute
-      escaped_name = cells.first.row.worksheet.name.gsub ''', "''"
+      escaped_name = first_cell.row.worksheet.name.gsub ''', "''"
       "'#{escaped_name}'!#{reference}"
     else
       reference
@@ -65,7 +67,7 @@ module Axlsx
   # @param [Array] cells
   # @return [Array]
   def self.sort_cells(cells)
-    cells.sort { |x, y| [x.index, x.row.row_index] <=> [y.index, y.row.row_index] }
+    cells.sort_by(&:pos)
   end
 
   #global reference html entity encoding

data/test/drawing/tc_bar_3D_chart.rb

@@ -32,18 +32,19 @@ class TestBar3DChart < Test::Unit::TestCase
    assert(@chart.grouping == :standard)
  end
 
+  def test_gap_width
+    assert_raise(ArgumentError, "require valid gap width") { @chart.gap_width = -1 }
+    assert_raise(ArgumentError, "require valid gap width") { @chart.gap_width = 501 }
+    assert_nothing_raised("allow valid gapWidth") { @chart.gap_width = 200 }
+    assert_equal(@chart.gap_width, 200, 'gap width is incorrect')
+  end
 
- def test_gapWidth
-   assert_raise(ArgumentError, "require valid gap width") { @chart.gap_width = 200 }
-   assert_nothing_raised("allow valid gapWidth") { @chart.gap_width = "200%" }
-   assert(@chart.gap_width == "200%")
- end
-
- def test_gapDepth
-   assert_raise(ArgumentError, "require valid gap_depth") { @chart.gap_depth = 200 }
-   assert_nothing_raised("allow valid gap_depth") { @chart.gap_depth = "200%" }
-   assert(@chart.gap_depth == "200%")
- end
+  def test_gap_depth
+    assert_raise(ArgumentError, "require valid gap_depth") { @chart.gap_depth = -1 }
+    assert_raise(ArgumentError, "require valid gap_depth") { @chart.gap_depth = 501 }
+    assert_nothing_raised("allow valid gap_depth") { @chart.gap_depth = 200 }
+    assert_equal(@chart.gap_depth, 200, 'gap depth is incorrect')
+  end
 
   def test_shape
     assert_raise(ArgumentError, "require valid shape") { @chart.shape = :star }
@@ -68,4 +69,18 @@ class TestBar3DChart < Test::Unit::TestCase
     val_axis_position = str.index(@chart.axes[:val_axis].id.to_s)
     assert(cat_axis_position < val_axis_position, "cat_axis must occur earlier than val_axis in the XML")
   end
+
+  def test_to_xml_string_has_gap_depth
+    gap_depth_value = rand(0..500)
+    @chart.gap_depth = gap_depth_value
+    doc = Nokogiri::XML(@chart.to_xml_string)
+    assert_equal(doc.xpath("//c:bar3DChart/c:gapDepth").first.attribute('val').value, gap_depth_value.to_s)
+  end
+
+  def test_to_xml_string_has_gap_width
+    gap_width_value = rand(0..500)
+    @chart.gap_width = gap_width_value
+    doc = Nokogiri::XML(@chart.to_xml_string)
+    assert_equal(doc.xpath("//c:bar3DChart/c:gapWidth").first.attribute('val').value, gap_width_value.to_s)
+  end
 end

data/test/drawing/tc_bar_chart.rb

@@ -32,18 +32,19 @@ class TestBarChart < Test::Unit::TestCase
    assert(@chart.grouping == :standard)
  end
 
+  def test_gap_width
+    assert_raise(ArgumentError, "require valid gap width") { @chart.gap_width = -1 }
+    assert_raise(ArgumentError, "require valid gap width") { @chart.gap_width = 501 }
+    assert_nothing_raised("allow valid gap width") { @chart.gap_width = 200 }
+    assert_equal(@chart.gap_width, 200, 'gap width is incorrect')
+  end
 
- def test_gapWidth
-   assert_raise(ArgumentError, "require valid gap width") { @chart.gap_width = 200 }
-   assert_nothing_raised("allow valid gapWidth") { @chart.gap_width = "200%" }
-   assert(@chart.gap_width == "200%")
- end
-
- def test_gapDepth
-   assert_raise(ArgumentError, "require valid gap_depth") { @chart.gap_depth = 200 }
-   assert_nothing_raised("allow valid gap_depth") { @chart.gap_depth = "200%" }
-   assert(@chart.gap_depth == "200%")
- end
+  def test_overlap
+    assert_raise(ArgumentError, "require valid overlap") { @chart.overlap = -101 }
+    assert_raise(ArgumentError, "require valid overlap") { @chart.overlap = 101 }
+    assert_nothing_raised("allow valid overlap") { @chart.overlap = 100 }
+    assert_equal(@chart.overlap, 100, 'overlap is incorrect')
+  end
 
   def test_shape
     assert_raise(ArgumentError, "require valid shape") { @chart.shape = :star }
@@ -68,4 +69,18 @@ class TestBarChart < Test::Unit::TestCase
     val_axis_position = str.index(@chart.axes[:val_axis].id.to_s)
     assert(cat_axis_position < val_axis_position, "cat_axis must occur earlier than val_axis in the XML")
   end
+
+  def test_to_xml_string_has_gap_width
+    gap_width_value = rand(0..500)
+    @chart.gap_width = gap_width_value
+    doc = Nokogiri::XML(@chart.to_xml_string)
+    assert_equal(doc.xpath("//c:barChart/c:gapWidth").first.attribute('val').value, gap_width_value.to_s)
+  end
+
+  def test_to_xml_string_has_overlap
+    overlap_value = rand(-100..100)
+    @chart.overlap = overlap_value
+    doc = Nokogiri::XML(@chart.to_xml_string)
+    assert_equal(doc.xpath("//c:barChart/c:overlap").first.attribute('val').value, overlap_value.to_s)
+  end
 end

data/test/drawing/tc_bar_series.rb

@@ -6,13 +6,21 @@ class TestBarSeries < Test::Unit::TestCase
     p = Axlsx::Package.new
     @ws = p.workbook.add_worksheet :name=>"hmmm"
     @chart = @ws.add_chart Axlsx::Bar3DChart, :title => "fishery"
-    @series = @chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob", :colors => ['FF0000', '00FF00', '0000FF'], :shape => :cone
+    @series = @chart.add_series(
+      data: [0, 1, 2],
+      labels: ['zero', 'one', 'two'],
+      title: 'bob',
+      colors: ['FF0000', '00FF00', '0000FF'],
+      shape: :cone,
+      series_color: '5A5A5A'
+    )
   end
 
   def test_initialize
     assert_equal(@series.title.text, "bob", "series title has been applied")
     assert_equal(@series.data.class, Axlsx::NumDataSource, "data option applied")
     assert_equal(@series.shape, :cone, "series shape has been applied")
+    assert_equal(@series.series_color, '5A5A5A', 'series color has been applied')
     assert(@series.data.is_a?(Axlsx::NumDataSource))
     assert(@series.labels.is_a?(Axlsx::AxDataSource))
   end
@@ -33,5 +41,6 @@ class TestBarSeries < Test::Unit::TestCase
       assert_equal(doc.xpath("//c:dPt/c:idx[@val='#{index}']").size,1)
       assert_equal(doc.xpath("//c:dPt/c:spPr/a:solidFill/a:srgbClr[@val='#{@series.colors[index]}']").size,1)
     end
+    assert_equal(doc.xpath('//c:spPr[not(ancestor::c:dPt)]/a:solidFill/a:srgbClr').first.get_attribute('val'), '5A5A5A', 'series color has been applied')
   end
 end

data/test/drawing/tc_drawing.rb

@@ -23,7 +23,7 @@ class TestDrawing < Test::Unit::TestCase
   end
 
   def test_add_image
-    src = File.dirname(__FILE__) + "/../../examples/image1.jpeg"
+    src = File.dirname(__FILE__) + "/../fixtures/image1.jpeg"
     image = @ws.add_image(:image_src => src, :start_at=>[0,0], :width=>600, :height=>400)
     assert(@ws.drawing.anchors.last.is_a?(Axlsx::OneCellAnchor))
     assert(image.is_a?(Axlsx::Pic))
@@ -31,7 +31,7 @@ class TestDrawing < Test::Unit::TestCase
     assert_equal(400, image.height)
   end
   def test_add_two_cell_anchor_image
-     src = File.dirname(__FILE__) + "/../../examples/image1.jpeg"
+     src = File.dirname(__FILE__) + "/../fixtures/image1.jpeg"
      image = @ws.add_image(:image_src => src, :start_at=>[0,0], :end_at => [15,0])
     assert(@ws.drawing.anchors.last.is_a?(Axlsx::TwoCellAnchor))
     assert(image.is_a?(Axlsx::Pic))

data/test/drawing/tc_hyperlink.rb

@@ -5,7 +5,7 @@ class TestHyperlink < Test::Unit::TestCase
   def setup
     @p = Axlsx::Package.new
     ws = @p.workbook.add_worksheet
-    @test_img =  File.dirname(__FILE__) + "/../../examples/image1.jpeg"
+    @test_img =  File.dirname(__FILE__) + "/../fixtures/image1.jpeg"
     @image = ws.add_image :image_src => @test_img, :hyperlink => "http://axlsx.blogspot.com"
     @hyperlink = @image.hyperlink
   end

data/test/drawing/tc_one_cell_anchor.rb

@@ -5,7 +5,7 @@ class TestOneCellAnchor < Test::Unit::TestCase
   def setup
     @p = Axlsx::Package.new
     @ws = @p.workbook.add_worksheet
-    @test_img =  File.dirname(__FILE__) + "/../../examples/image1.jpeg"
+    @test_img =  File.dirname(__FILE__) + "/../fixtures/image1.jpeg"
     @image = @ws.add_image :image_src => @test_img
     @anchor = @image.anchor
   end

data/test/drawing/tc_pic.rb

@@ -5,10 +5,10 @@ class TestPic < Test::Unit::TestCase
   def setup
     @p = Axlsx::Package.new
     ws = @p.workbook.add_worksheet
-    @test_img = @test_img_jpg =  File.dirname(__FILE__) + "/../../examples/image1.jpeg"
-    @test_img_png =  File.dirname(__FILE__) + "/../../examples/image1.png"
-    @test_img_gif =  File.dirname(__FILE__) + "/../../examples/image1.gif"
-    @test_img_fake =  File.dirname(__FILE__) + "/../../examples/image1_fake.jpg"
+    @test_img = @test_img_jpg =  File.dirname(__FILE__) + "/../fixtures/image1.jpeg"
+    @test_img_png =  File.dirname(__FILE__) + "/../fixtures/image1.png"
+    @test_img_gif =  File.dirname(__FILE__) + "/../fixtures/image1.gif"
+    @test_img_fake =  File.dirname(__FILE__) + "/../fixtures/image1_fake.jpg"
     @image = ws.add_image :image_src => @test_img, :hyperlink => 'https://github.com/randym', :tooltip => "What's up doc?", :opacity => 5
   end
 

data/test/drawing/tc_pie_series.rb

@@ -20,12 +20,13 @@ class TestPieSeries < Test::Unit::TestCase
     assert_raise(ArgumentError, "require valid explosion") { @series.explosion = :lots }
     assert_nothing_raised("allow valid explosion") { @series.explosion = 20 }
     assert(@series.explosion == 20)
+    # issue 58 - explosion caused to_xml_string to fail - now tested
+    assert_nothing_raised("allow to_xml_string") { @series.to_xml_string }
   end
 
   def test_to_xml_string
     doc = Nokogiri::XML(@series.to_xml_string)
     assert(doc.xpath("//srgbClr[@val='#{@series.colors[0]}']"))
-
   end
   #TODO test unique serialization parts
 

data/test/tc_helper.rb

@@ -8,5 +8,3 @@ end
 require 'test/unit'
 require "timecop"
 require "axlsx.rb"
-# MIME detection for Microsoft Office 2007+ formats
-require 'mimemagic/overlay'

data/test/tc_package.rb

@@ -65,7 +65,7 @@ class TestPackage < Test::Unit::TestCase
     end
 
     @fname = 'axlsx_test_serialization.xlsx'
-    img = File.expand_path('../../examples/image1.jpeg', __FILE__)
+    img = File.expand_path('../fixtures/image1.jpeg', __FILE__)
     ws.add_image(:image_src => img, :noSelect => true, :noMove => true, :hyperlink=>"http://axlsx.blogspot.com") do |image|
       image.width=720
       image.height=666
@@ -73,12 +73,12 @@ class TestPackage < Test::Unit::TestCase
       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|
+    ws.add_image :image_src => File.expand_path('../fixtures/image1.gif', __FILE__) do |image|
       image.start_at 0, 20
       image.width=360
       image.height=333
     end
-    ws.add_image :image_src => File.expand_path('../../examples/image1.png', __FILE__) do |image|
+    ws.add_image :image_src => File.expand_path('../fixtures/image1.png', __FILE__) do |image|
       image.start_at 9, 20
       image.width = 180
       image.height = 167
@@ -127,18 +127,85 @@ class TestPackage < Test::Unit::TestCase
   end
 
   def test_serialization
-    assert_nothing_raised do
-      begin
-        @package.serialize(@fname)
-        zf = Zip::File.open(@fname)
-        @package.send(:parts).each{ |part| zf.get_entry(part[:entry]) }
-        File.delete(@fname)
-      rescue Errno::EACCES
-        puts "WARNING:: test_serialization requires write access."
-      end
+    @package.serialize(@fname)
+    assert_zip_file_matches_package(@fname, @package)
+    assert_created_with_rubyzip(@fname, @package)
+    File.delete(@fname)
+  end
+
+  def test_serialization_with_zip_command
+    @package.serialize(@fname, zip_command: "zip")
+    assert_zip_file_matches_package(@fname, @package)
+    assert_created_with_zip_command(@fname, @package)
+    File.delete(@fname)
+  end
+
+  def test_serialization_with_zip_command_and_absolute_path
+    fname = "#{Dir.tmpdir}/#{@fname}"
+    @package.serialize(fname, zip_command: "zip")
+    assert_zip_file_matches_package(fname, @package)
+    assert_created_with_zip_command(fname, @package)
+    File.delete(fname)
+  end
+
+  def test_serialization_with_invalid_zip_command
+    assert_raises Axlsx::ZipCommand::ZipError do
+      @package.serialize(@fname, zip_command: "invalid_zip")
     end
   end
 
+  def assert_zip_file_matches_package(fname, package)
+    zf = Zip::File.open(fname)
+    package.send(:parts).each{ |part| zf.get_entry(part[:entry]) }
+  end
+
+  def assert_created_with_rubyzip(fname, package)
+    assert_equal 2098, get_mtime(fname, package).year, "XLSX files created with RubyZip have 2098 as the file mtime"
+  end
+
+  def assert_created_with_zip_command(fname, package)
+    assert_equal Time.now.utc.year, get_mtime(fname, package).year, "XLSX files created with a zip command have the current year as the file mtime"
+  end
+
+  def get_mtime(fname, package)
+    zf = Zip::File.open(fname)
+    part = package.send(:parts).first
+    entry = zf.get_entry(part[:entry])
+    entry.mtime.utc
+  end
+
+  def test_serialization_with_deprecated_argument
+    warnings = capture_warnings do
+      @package.serialize(@fname, false)
+    end
+    assert_equal 1, warnings.size
+    assert_includes warnings.first, "confirm_valid as a boolean is deprecated"
+    File.delete(@fname)
+  end
+
+  def test_serialization_with_deprecated_three_arguments
+    warnings = capture_warnings do
+      @package.serialize(@fname, true, zip_command: "zip")
+    end
+    assert_zip_file_matches_package(@fname, @package)
+    assert_created_with_zip_command(@fname, @package)
+    assert_equal 2, warnings.size
+    assert_includes warnings.first, "with 3 arguments is deprecated"
+    File.delete(@fname)
+  end
+
+  def capture_warnings(&block)
+    original_warn = Kernel.instance_method(:warn)
+    warnings = []
+    Kernel.send(:define_method, :warn) { |string| warnings << string }
+    block.call
+    original_verbose = $VERBOSE
+    $VERBOSE = nil
+    Kernel.send(:define_method, :warn, original_warn)
+    $VERBOSE = original_verbose
+    warnings
+  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
@@ -161,7 +228,7 @@ class TestPackage < Test::Unit::TestCase
   end
 
   def test_serialization_creates_files_with_excel_mime_type
-    assert_equal(MimeMagic.by_magic(@package.to_stream).type,
+    assert_equal(Marcel::MimeType.for(@package.to_stream),
                  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
   end
 

data/test/util/tc_mime_type_utils.rb

@@ -1,7 +1,7 @@
 require 'tc_helper.rb'
 class TestMimeTypeUtils < Test::Unit::TestCase
   def setup
-    @test_img = File.dirname(__FILE__) + "/../../examples/image1.jpeg"
+    @test_img = File.dirname(__FILE__) + "/../fixtures/image1.jpeg"
   end
 
   def teardown

data/test/util/tc_validators.rb

@@ -127,7 +127,7 @@ class TestValidators < Test::Unit::TestCase
     assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 0 }
 
     #data_validation_type
-    [:custom, :data, :decimal, :list, :none, :textLength, :time, :whole].each do |sym|
+    [:custom, :data, :decimal, :list, :none, :textLength, :date, :time, :whole].each do |sym|
       assert_nothing_raised { Axlsx.validate_data_validation_type sym }
     end
     assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style :other_symbol }

data/test/workbook/worksheet/tc_cell.rb

@@ -71,6 +71,13 @@ class TestCell < Test::Unit::TestCase
     assert_equal(@c.value, now.to_time)
   end
 
+  def test_date
+    @c.type = :date
+    now = Time.now
+    @c.value = now
+    assert_equal(@c.value, now.to_date)
+  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}
@@ -100,6 +107,12 @@ class TestCell < Test::Unit::TestCase
 
   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, "1e1"), :float)
+    assert_equal(@c.send(:cell_type_from_value, "1e#{Float::MAX_10_EXP}"), :float)
+    assert_equal(@c.send(:cell_type_from_value, "1e#{Float::MAX_10_EXP + 1}"), :string)
+    assert_equal(@c.send(:cell_type_from_value, "1e-1"), :float)
+    assert_equal(@c.send(:cell_type_from_value, "1e#{Float::MIN_10_EXP}"), :float)
+    assert_equal(@c.send(:cell_type_from_value, "1e#{Float::MIN_10_EXP - 1}"), :string)
     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)
@@ -114,6 +127,31 @@ class TestCell < Test::Unit::TestCase
     assert_equal(:iso_8601, @c.send(:cell_type_from_value, '2008-08-30T01:45:36.123+09:00'))
   end
 
+  def test_cell_type_from_value_looks_like_number_but_is_not
+    mimic_number = Class.new do
+      def initialize(to_s_value)
+        @to_s_value = to_s_value
+      end
+
+      def to_s
+        @to_s_value
+      end
+    end
+
+    number_strings = [
+      '1',
+      '1234567890',
+      '1.0',
+      '1e1',
+      '0',
+      "1e#{Float::MIN_10_EXP}"
+    ]
+
+    number_strings.each do |number_string|
+      assert_equal(@c.send(:cell_type_from_value, mimic_number.new(number_string)), :string)
+    end
+  end
+
   def test_cast_value
     @c.type = :string
     assert_equal(@c.send(:cast_value, 1.0), "1.0")

data/test/workbook/worksheet/tc_pivot_table.rb

@@ -132,4 +132,12 @@ class TestPivotTable < Test::Unit::TestCase
     end
     shared_test_pivot_table_xml_validity(pivot_table)
   end
+
+  def test_add_pivot_table_with_format_options_on_data_field
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:E5') do |pt|
+      pt.data = [{:ref=>"Sales", :subtotal => 'sum', num_fmt: 4}]
+    end
+    doc = Nokogiri::XML(pivot_table.to_xml_string)
+    assert_equal('4', doc.at_css('dataFields dataField')['numFmtId'], 'adding format options to pivot_table')
+  end
 end

data/test/workbook/worksheet/tc_pivot_table_cache_definition.rb

@@ -51,4 +51,12 @@ class TestPivotTableCacheDefinition < Test::Unit::TestCase
     assert(errors.empty?, "error free validation")
   end
 
+  def test_to_xml_string_for_special_characters
+    cell = @ws.rows.first.cells.first
+    cell.value = "&><'\""
+
+    doc = Nokogiri::XML(@cache_definition.to_xml_string)
+    errors = doc.errors
+    assert(errors.empty?, "invalid xml: #{errors.map(&:to_s).join(', ')}")
+  end
 end

data/test/workbook/worksheet/tc_row.rb

@@ -136,4 +136,25 @@ class TestRow < Test::Unit::TestCase
     assert_equal(r_s_xml.xpath(".//row[@r=1][@ht=20][@customHeight=1]").size, 1)
   end
 
+  def test_offsets
+    offset = 3
+    values = [1,2,3,4,5]
+    r = @ws.add_row(values, offset: offset, style: 1)
+    r.cells.each_with_index do |c, index| 
+      assert_equal(c.style, index < offset ? 0 : 1)
+      assert_equal(c.value, index < offset ? nil : values[index - offset])
+    end
+  end
+
+  def test_offsets_with_styles
+    offset = 3
+    values = [1,2,3,4,5]
+    styles = (1..5).map{ @ws.workbook.styles.add_style }
+    r = @ws.add_row(values, offset: offset, style: styles)
+    r.cells.each_with_index do |c, index| 
+      assert_equal(c.style, index < offset ? 0 : styles[index-offset])
+      assert_equal(c.value, index < offset ? nil : values[index - offset])
+    end
+  end
+
 end

data/test/workbook/worksheet/tc_table.rb

@@ -64,4 +64,14 @@ class TestTable < Test::Unit::TestCase
     end
     assert(errors.empty?, "error free validation")
   end
+
+  def test_to_xml_string_for_special_characters
+    cell = @ws.rows.first.cells.first
+    cell.value = "&><'\""
+
+    table = @ws.add_table("A1:D5")
+    doc = Nokogiri::XML(table.to_xml_string)
+    errors = doc.errors
+    assert(errors.empty?, "invalid xml: #{errors.map(&:to_s).join(', ')}")
+  end
 end

data/test/workbook/worksheet/tc_worksheet.rb

@@ -29,15 +29,28 @@ class TestWorksheet < Test::Unit::TestCase
     assert_raises(ArgumentError) { @ws.name = 'foo?bar' }
   end
 
+  def test_name_unique
+    assert_raise(ArgumentError, "worksheet name must be unique") { n = @ws.name; @ws.workbook.add_worksheet(:name=> n) }
+  end
+
+  def test_name_unique_only_checks_other_worksheet_names
+    assert_nothing_raised { @ws.name = @ws.name }
+    assert_nothing_raised { Axlsx::Package.new.workbook.add_worksheet :name => 'Sheet1' }
+  end
+
   def test_exception_if_name_too_long
     assert_nothing_raised { @ws.name = 'x' * 31 }
     assert_raises(ArgumentError) { @ws.name = 'x' * 32 }
   end
 
   def test_exception_if_name_too_long_because_of_multibyte_characters
-    three_byte_character = "✔"
-    assert_nothing_raised { @ws.name = 'x' * 28 + three_byte_character}
-    assert_raises(ArgumentError) { @ws.name = 'x' * 29 + three_byte_character }
+    four_characters_for_excel = "\u{1F1EB 1F1F7}" # french flag emoji
+    assert_raises(ArgumentError, "name too long!") do
+      @ws.name = four_characters_for_excel + "x" * 28
+    end
+    assert_nothing_raised { @ws.name = "#{four_characters_for_excel}123456789012345678901234567" }
+    assert_nothing_raised { @ws.name = "123456789012345678901234567890…" }
+    assert_nothing_raised { @ws.name = "123456789012345678901234567890✔" }
   end
 
   def test_page_margins
@@ -460,21 +473,6 @@ class TestWorksheet < Test::Unit::TestCase
     assert_equal(@ws.relationships.size, 4, "adding a pivot table adds 1 relationship")
   end
 
-
-  def test_name_unique
-    assert_raise(ArgumentError, "worksheet name must be unique") { n = @ws.name; @ws.workbook.add_worksheet(:name=> n) }
-  end
-
-  def test_name_unique_only_checks_other_worksheet_names
-    assert_nothing_raised { @ws.name = @ws.name }
-    assert_nothing_raised { Axlsx::Package.new.workbook.add_worksheet :name => 'Sheet1' }
-  end
-
-  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_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")