caxlsx 3.2.0 → 3.3.0

data/test/stylesheet/tc_styles.rb

@@ -1,309 +0,0 @@
-require 'tc_helper.rb'
-
-class TestStyles < Test::Unit::TestCase
-  def setup
-    @styles = Axlsx::Styles.new
-  end
-  def teardown
-  end
-
-  def test_valid_document
-    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
-    doc = Nokogiri::XML(@styles.to_xml_string)
-    errors = []
-    schema.validate(doc).each do |error|
-      errors.push error
-      puts error.message
-    end
-    assert(errors.size == 0)
-  end
-
-  def test_add_style_border_hash
-    border_count = @styles.borders.size
-    @styles.add_style :border => {:style => :thin, :color => "FFFF0000"}
-    assert_equal(@styles.borders.size, border_count + 1)
-    assert_equal(@styles.borders.last.prs.last.color.rgb, "FFFF0000")
-    assert_raise(ArgumentError) { @styles.add_style :border => {:color => "FFFF0000"} }
-    assert_equal @styles.borders.last.prs.size, 4
-  end
-
-  def test_add_style_border_array
-    prev_border_count = @styles.borders.size
-
-    borders_array = [
-      {:style => :thin, :color => "DDDDDD"},
-      {:edges => [:top], :style => :thin, :color => "000000"},
-      {:edges => [:bottom], :style => :thick, :color => "FF0000"},
-      {:edges => [:left], :style => :dotted, :color => "FFFF00"},
-      {:edges => [:right], :style => :dashed, :color => "FFFFFF"},
-      {:style => :thick, :color => "CCCCCC"},
-    ]
-
-    @styles.add_style(border: borders_array)
-
-    assert_equal(@styles.borders.size, (prev_border_count+1))
-
-    current_border = @styles.borders.last
-  
-    borders_array.each do |b_opts|
-      if b_opts[:edges]
-        border_pr = current_border.prs.detect{|x| x.name == b_opts[:edges].first }
-        assert_equal(border_pr.color.rgb, "FF#{b_opts[:color]}")
-      end
-    end
-  end
-
-  def test_add_style_border_edges
-    @styles.add_style :border => { :style => :thin, :color => "0000FFFF", :edges => [:top, :bottom] }
-    parts = @styles.borders.last.prs
-    parts.each { |pr| assert_equal(pr.color.rgb, "0000FFFF", "Style is applied to #{pr.name} properly") }
-    assert((parts.map { |pr| pr.name.to_s }.sort && ['bottom', 'top']).size == 2, "specify two edges, and you get two border prs")
-  end
-
-  def test_do_not_alter_options_in_add_style
-    #This should test all options, but for now - just the bits that we know caused some pain
-    options = { :border => { :style => :thin, :color =>"FF000000" } }
-    @styles.add_style options
-    assert_equal options[:border][:style], :thin, 'thin style is stil in option'
-    assert_equal options[:border][:color], "FF000000", 'color is stil in option'
-  end
-
-  def test_parse_num_fmt
-    f_code = {:format_code => "YYYY/MM"}
-    num_fmt = {:num_fmt => 5}
-    assert_equal(@styles.parse_num_fmt_options, nil, 'noop if neither :format_code or :num_fmt exist')
-    max = @styles.numFmts.map{ |nf| nf.numFmtId }.max
-    @styles.parse_num_fmt_options(f_code)
-    assert_equal(@styles.numFmts.last.numFmtId, max + 1, "new numfmts gets next available id")
-    assert(@styles.parse_num_fmt_options(num_fmt).is_a?(Integer), "Should return the provided num_fmt if not dxf")
-    assert(@styles.parse_num_fmt_options(num_fmt.merge({:type => :dxf})).is_a?(Axlsx::NumFmt), "Makes a new NumFmt if dxf")
-  end
-
-  def test_parse_border_options_hash_required_keys
-    assert_raise(ArgumentError, "Require color key") { @styles.parse_border_options(:border => { :style => :thin }) }
-    assert_raise(ArgumentError, "Require style key") { @styles.parse_border_options(:border => { :color => "FF0d0d0d" }) }
-    assert_nothing_raised { @styles.parse_border_options(:border => { :style => :thin, :color => "FF000000"} ) }
-  end
-
-  def test_parse_border_basic_options
-    b_opts = {:border => { :diagonalUp => 1, :edges => [:left, :right], :color => "FFDADADA", :style => :thick } }
-    b = @styles.parse_border_options b_opts
-    assert(b.is_a? Integer)
-    assert_equal(@styles.parse_border_options(b_opts.merge({:type => :dxf})).class,Axlsx::Border)
-    assert(@styles.borders.last.diagonalUp == 1, "border options are passed in to the initializer")
-  end
-
-  def test_parse_border_options_edges
-    b_opts = {:border => { :diagonalUp => 1, :edges => [:left, :right], :color => "FFDADADA", :style => :thick } }
-    @styles.parse_border_options b_opts
-    b = @styles.borders.last
-    left = b.prs.select { |bpr| bpr.name == :left }[0]
-    right = b.prs.select { |bpr| bpr.name == :right }[0]
-    top = b.prs.select { |bpr| bpr.name == :top }[0]
-    bottom = b.prs.select { |bpr| bpr.name == :bottom }[0]
-    assert_equal(top, nil, "unspecified top edge should not be created")
-    assert_equal(bottom, nil, "unspecified bottom edge should not be created")
-    assert(left.is_a?(Axlsx::BorderPr), "specified left edge is set")
-    assert(right.is_a?(Axlsx::BorderPr), "specified right edge is set")
-    assert_equal(left.style,right.style, "edge parts have the same style")
-    assert_equal(left.style, :thick, "the style is THICK")
-    assert_equal(right.color.rgb,left.color.rgb, "edge parts are colors are the same")
-    assert_equal(right.color.rgb,"FFDADADA", "edge color rgb is correct")
-  end
-
-  def test_parse_border_options_noop
-    assert_equal(@styles.parse_border_options({}), nil, "noop if the border key is not in options")
-  end
-
-  def test_parse_border_options_integer_xf
-    assert_equal(@styles.parse_border_options(:border => 1), 1)
-    assert_raise(ArgumentError, "unknown border index") {@styles.parse_border_options(:border => 100) }
-  end
-
-  def test_parse_border_options_integer_dxf
-    b_opts = { :border => { :edges => [:left, :right], :color => "FFFFFFFF", :style=> :thick } }
-    b = @styles.parse_border_options(b_opts)
-    b2 = @styles.parse_border_options(:border => b, :type => :dxf)
-    assert(b2.is_a?(Axlsx::Border), "Cloned existing border object")
-  end
-
-  def test_parse_alignment_options
-    assert_equal(@styles.parse_alignment_options {}, nil, "noop if :alignment is not set")
-    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",
-      :sz => 20,
-      :b => 1,
-      :i => 1,
-      :u => :single,
-      :strike => 1,
-      :outline => 1,
-      :shadow => 1,
-      :charset => 9,
-      :family => 1,
-      :font_name => "woot font"
-    }
-    assert_equal(@styles.parse_font_options {}, nil, "noop if no font keys are set")
-    assert(@styles.parse_font_options(:b=>1).is_a?(Integer), "return index of font if not :dxf type")
-    assert_equal(@styles.parse_font_options(:b=>1, :type => :dxf).class, Axlsx::Font, "return font object if :dxf type")
-
-    f = @styles.parse_font_options(options.merge(:type => :dxf))
-    color = options.delete(:fg_color)
-    options[:name] = options.delete(:font_name)
-    options.each do |key, value|
-      assert_equal(f.send(key), value, "assert that #{key} was parsed")
-    end
-    assert_equal(f.color.rgb, color)
-  end
-
-  def test_parse_fill_options
-    assert_equal(@styles.parse_fill_options {}, nil, "noop if no fill keys are set")
-    assert(@styles.parse_fill_options(:bg_color => "DE").is_a?(Integer), "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.bgColor.rgb == "FFDEDEDE")
-  end
-
-  def test_parse_protection_options
-    assert_equal(@styles.parse_protection_options {}, nil, "noop if no protection keys are set")
-    assert_equal(@styles.parse_protection_options(:hidden => 1).class, Axlsx::CellProtection, "creates a new cell protection object")
-  end
-
-  def test_add_style
-    fill_count = @styles.fills.size
-    font_count = @styles.fonts.size
-    xf_count = @styles.cellXfs.size
-
-    @styles.add_style :bg_color=>"FF000000", :fg_color=>"FFFFFFFF", :sz=>13, :num_fmt=>Axlsx::NUM_FMT_PERCENT, :alignment=>{:horizontal=>:left}, :border=>Axlsx::STYLE_THIN_BORDER, :hidden=>true, :locked=>true
-    assert_equal(@styles.fills.size, fill_count+1)
-    assert_equal(@styles.fonts.size, font_count+1)
-    assert_equal(@styles.cellXfs.size, xf_count+1)
-    xf = @styles.cellXfs.last
-    assert_equal(xf.fillId, (@styles.fills.size-1), "points to the last created fill")
-    assert_equal(@styles.fills.last.fill_type.fgColor.rgb, "FF000000", "fill created with color")
-
-    assert_equal(xf.fontId, (@styles.fonts.size-1), "points to the last created font")
-    assert_equal(@styles.fonts.last.sz, 13, "font sz applied")
-    assert_equal(@styles.fonts.last.color.rgb, "FFFFFFFF", "font color applied")
-
-    assert_equal(xf.borderId, Axlsx::STYLE_THIN_BORDER, "border id is set")
-    assert_equal(xf.numFmtId, Axlsx::NUM_FMT_PERCENT, "number format id is set")
-
-    assert(xf.alignment.is_a?(Axlsx::CellAlignment), "alignment was created")
-    assert_equal(xf.alignment.horizontal, :left, "horizontal alignment applied")
-    assert_equal(xf.protection.hidden, true, "hidden protection set")
-    assert_equal(xf.protection.locked, true, "cell locking set")
-    assert_raise(ArgumentError, "should reject invalid borderId") { @styles.add_style :border => 2 }
-
-
-    assert_equal(xf.applyProtection, true, "protection applied")
-    assert_equal(xf.applyBorder, true, "border applied")
-    assert_equal(xf.applyNumberFormat,true, "number format applied")
-    assert_equal(xf.applyAlignment, true, "alignment applied")
-  end
-
-  def test_basic_add_style_dxf
-    border_count = @styles.borders.size
-    @styles.add_style :border => {:style => :thin, :color => "FFFF0000"}, :type => :dxf
-    assert_equal(@styles.borders.size, border_count, "styles borders not affected")
-    assert_equal(@styles.dxfs.last.border.prs.last.color.rgb, "FFFF0000")
-    assert_raise(ArgumentError) { @styles.add_style :border => {:color => "FFFF0000"}, :type => :dxf }
-    assert_equal @styles.borders.last.prs.size, 4
-  end
-
-  def test_add_style_dxf
-    fill_count = @styles.fills.size
-    font_count = @styles.fonts.size
-    dxf_count = @styles.dxfs.size
-
-    style = @styles.add_style :bg_color=>"FF000000", :fg_color=>"FFFFFFFF", :sz=>13, :alignment=>{:horizontal=>:left}, :border=>{:style => :thin, :color => "FFFF0000"}, :hidden=>true, :locked=>true, :type => :dxf
-    assert_equal(@styles.dxfs.size, dxf_count+1)
-    assert_equal(0, style, "returns the zero-based dxfId")
-
-    dxf = @styles.dxfs.last
-    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")
-
-    assert(dxf.border.is_a?(Axlsx::Border), "border is set")
-    assert_equal(nil, dxf.numFmt, "number format is not set")
-
-    assert(dxf.alignment.is_a?(Axlsx::CellAlignment), "alignment was created")
-    assert_equal(dxf.alignment.horizontal, :left, "horizontal alignment applied")
-    assert_equal(dxf.protection.hidden, true, "hidden protection set")
-    assert_equal(dxf.protection.locked, true, "cell locking set")
-    assert_raise(ArgumentError, "should reject invalid borderId") { @styles.add_style :border => 3 }
-  end
-
-  def test_multiple_dxf
-    # add a second style
-    style = @styles.add_style :bg_color=>"00000000", :fg_color=>"FFFFFFFF", :sz=>13, :alignment=>{:horizontal=>:left}, :border=>{:style => :thin, :color => "FFFF0000"}, :hidden=>true, :locked=>true, :type => :dxf
-    assert_equal(0, style, "returns the first dxfId")
-    style = @styles.add_style :bg_color=>"FF000000", :fg_color=>"FFFFFFFF", :sz=>13, :alignment=>{:horizontal=>:left}, :border=>{:style => :thin, :color => "FFFF0000"}, :hidden=>true, :locked=>true, :type => :dxf
-    assert_equal(1, style, "returns the second dxfId")
-  end
-
-  def test_valid_document_with_font_options
-    font_options = {
-      :fg_color => "FF050505",
-      :sz => 20,
-      :b => 1,
-      :i => 1,
-      :u => :single,
-      :strike => 1,
-      :outline => 1,
-      :shadow => 1,
-      :charset => 9,
-      :family => 1,
-      :font_name => "woot font"
-    }
-    @styles.add_style font_options
-
-    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
-    doc = Nokogiri::XML(@styles.to_xml_string)
-    errors = []
-    schema.validate(doc).each do |error|
-      errors.push error
-      puts error.message
-    end
-    assert(errors.size == 0)
-  end
-
-  def test_border_top_without_border_regression
-    ### https://github.com/axlsx-styler-gem/axlsx_styler/issues/31
-    
-    borders = {
-      top: { style: :double, color: '0000FF' },
-      right: { style: :thick, color: 'FF0000' },
-      bottom: { style: :double, color: '0000FF' },
-      left: { style: :thick, color: 'FF0000' }
-    }
-
-    borders.each do |edge, b_opts|
-      @styles.add_style("border_#{edge}".to_sym => b_opts)
-
-      current_border = @styles.borders.last
-
-      border_pr = current_border.prs.detect{|x| x.name == edge }
-      assert_equal(border_pr.color.rgb, "FF#{b_opts[:color]}")
-    end
-  
-  end
-end

data/test/stylesheet/tc_table_style.rb

@@ -1,44 +0,0 @@
-require 'tc_helper.rb'
-
-class TestTableStyle < Test::Unit::TestCase
-
-  def setup
-    @item = Axlsx::TableStyle.new "fisher"
-  end
-
-  def teardown
-  end
-
-  def test_initialiation
-    assert_equal(@item.name, "fisher")
-    assert_equal(@item.pivot, nil)
-    assert_equal(@item.table, nil)
-    ts = Axlsx::TableStyle.new 'price', :pivot => true, :table => true
-    assert_equal(ts.name, 'price')
-    assert_equal(ts.pivot, true)
-    assert_equal(ts.table, true)
-  end
-
-  def test_name
-    assert_raise(ArgumentError) { @item.name = -1.1 }
-    assert_nothing_raised { @item.name = "lovely table style" }
-    assert_equal(@item.name, "lovely table style")
-  end
-
-  def test_pivot
-    assert_raise(ArgumentError) { @item.pivot = -1.1 }
-    assert_nothing_raised { @item.pivot = true }
-    assert_equal(@item.pivot, true)
-  end
-
-  def test_table
-    assert_raise(ArgumentError) { @item.table = -1.1 }
-    assert_nothing_raised { @item.table = true }
-    assert_equal(@item.table, true)
-  end
-
-  def test_to_xml_string
-    doc = Nokogiri::XML(@item.to_xml_string)
-    assert(doc.xpath("//tableStyle[@name='#{@item.name}']"))
-  end
-end

data/test/stylesheet/tc_table_style_element.rb

@@ -1,45 +0,0 @@
-require 'tc_helper.rb'
-
-class TestTableStyleElement < Test::Unit::TestCase
-
-  def setup
-    @item = Axlsx::TableStyleElement.new
-  end
-
-  def teardown
-  end
-
-  def test_initialiation
-    assert_equal(@item.type, nil)
-    assert_equal(@item.size, nil)
-    assert_equal(@item.dxfId, nil)
-    options = { :type => :headerRow, :size => 10, :dxfId => 1 }
-
-    tse = Axlsx::TableStyleElement.new options
-    options.each { |key, value| assert_equal(tse.send(key.to_sym), value) }
-  end
-
-  def test_type
-    assert_raise(ArgumentError) { @item.type = -1.1 }
-    assert_nothing_raised { @item.type = :blankRow }
-    assert_equal(@item.type, :blankRow)
-  end
-
-  def test_size
-    assert_raise(ArgumentError) { @item.size = -1.1 }
-    assert_nothing_raised { @item.size = 2 }
-    assert_equal(@item.size, 2)
-  end
-
-  def test_dxfId
-    assert_raise(ArgumentError) { @item.dxfId = -1.1 }
-    assert_nothing_raised { @item.dxfId = 7 }
-    assert_equal(@item.dxfId, 7)
-  end
-  
-  def test_to_xml_string
-    doc = Nokogiri::XML(@item.to_xml_string)
-   @item.type = :headerRow
-    assert(doc.xpath("//tableStyleElement[@type='#{@item.type.to_s}']"))
-  end
-end

data/test/stylesheet/tc_table_styles.rb

@@ -1,29 +0,0 @@
-require 'tc_helper.rb'
-
-class TestTableStyles < Test::Unit::TestCase
-
-  def setup
-    @item = Axlsx::TableStyles.new
-  end
-
-  def teardown
-  end
-
-  def test_initialiation
-    assert_equal(@item.defaultTableStyle, "TableStyleMedium9")
-    assert_equal(@item.defaultPivotStyle, "PivotStyleLight16")
-  end
-
-  def test_defaultTableStyle
-    assert_raise(ArgumentError) { @item.defaultTableStyle = -1.1 }
-    assert_nothing_raised { @item.defaultTableStyle = "anyones guess" }
-    assert_equal(@item.defaultTableStyle, "anyones guess")
-  end
-
-  def test_defaultPivotStyle
-    assert_raise(ArgumentError) { @item.defaultPivotStyle = -1.1 }
-    assert_nothing_raised { @item.defaultPivotStyle = "anyones guess" }
-    assert_equal(@item.defaultPivotStyle, "anyones guess")
-  end
-
-end

data/test/stylesheet/tc_xf.rb

@@ -1,120 +0,0 @@
-require 'tc_helper.rb'
-
-class TestXf < Test::Unit::TestCase
-
-  def setup
-    @item = Axlsx::Xf.new
-  end
-
-  def teardown
-  end
-
-  def test_initialiation
-    assert_equal(@item.alignment, nil)
-    assert_equal(@item.protection, nil)
-    assert_equal(@item.numFmtId, nil)
-    assert_equal(@item.fontId, nil)
-    assert_equal(@item.fillId, nil)
-    assert_equal(@item.borderId, nil)
-    assert_equal(@item.xfId, nil)
-    assert_equal(@item.quotePrefix, nil)
-    assert_equal(@item.pivotButton, nil)
-    assert_equal(@item.applyNumberFormat, nil)
-    assert_equal(@item.applyFont, nil)
-    assert_equal(@item.applyFill, nil)
-    assert_equal(@item.applyBorder, nil)
-    assert_equal(@item.applyAlignment, nil)
-    assert_equal(@item.applyProtection, nil)
-  end
-
-  def test_alignment
-    assert_raise(ArgumentError) { @item.alignment = -1.1 }
-    assert_nothing_raised { @item.alignment = Axlsx::CellAlignment.new }
-    assert(@item.alignment.is_a?(Axlsx::CellAlignment))
-  end
-
-  def test_protection
-    assert_raise(ArgumentError) { @item.protection = -1.1 }
-    assert_nothing_raised { @item.protection = Axlsx::CellProtection.new }
-    assert(@item.protection.is_a?(Axlsx::CellProtection))
-  end
-
-  def test_numFmtId
-    assert_raise(ArgumentError) { @item.numFmtId = -1.1 }
-    assert_nothing_raised { @item.numFmtId = 0 }
-    assert_equal(@item.numFmtId, 0)
-  end
-
-  def test_fillId
-    assert_raise(ArgumentError) { @item.fillId = -1.1 }
-    assert_nothing_raised { @item.fillId = 0 }
-    assert_equal(@item.fillId, 0)
-  end
-
-  def test_fontId
-    assert_raise(ArgumentError) { @item.fontId = -1.1 }
-    assert_nothing_raised { @item.fontId = 0 }
-    assert_equal(@item.fontId, 0)
-  end
-
-  def test_borderId
-    assert_raise(ArgumentError) { @item.borderId = -1.1 }
-    assert_nothing_raised { @item.borderId = 0 }
-    assert_equal(@item.borderId, 0)
-  end
-
-  def test_xfId
-    assert_raise(ArgumentError) { @item.xfId = -1.1 }
-    assert_nothing_raised { @item.xfId = 0 }
-    assert_equal(@item.xfId, 0)
-  end
-
-  def test_quotePrefix
-    assert_raise(ArgumentError) { @item.quotePrefix = -1.1 }
-    assert_nothing_raised { @item.quotePrefix = false }
-    assert_equal(@item.quotePrefix, false)
-  end
-
-  def test_pivotButton
-    assert_raise(ArgumentError) { @item.pivotButton = -1.1 }
-    assert_nothing_raised { @item.pivotButton = false }
-    assert_equal(@item.pivotButton, false)
-  end
-
-  def test_applyNumberFormat
-    assert_raise(ArgumentError) { @item.applyNumberFormat = -1.1 }
-    assert_nothing_raised { @item.applyNumberFormat = false }
-    assert_equal(@item.applyNumberFormat, false)
-  end
-
-  def test_applyFont
-    assert_raise(ArgumentError) { @item.applyFont = -1.1 }
-    assert_nothing_raised { @item.applyFont = false }
-    assert_equal(@item.applyFont, false)
-  end
-
-  def test_applyFill
-    assert_raise(ArgumentError) { @item.applyFill = -1.1 }
-    assert_nothing_raised { @item.applyFill = false }
-    assert_equal(@item.applyFill, false)
-  end
-
-  def test_applyBorder
-    assert_raise(ArgumentError) { @item.applyBorder = -1.1 }
-    assert_nothing_raised { @item.applyBorder = false }
-    assert_equal(@item.applyBorder, false)
-  end
-
-  def test_applyAlignment
-    assert_raise(ArgumentError) { @item.applyAlignment = -1.1 }
-    assert_nothing_raised { @item.applyAlignment = false }
-    assert_equal(@item.applyAlignment, false)
-  end
-
-  def test_applyProtection
-    assert_raise(ArgumentError) { @item.applyProtection = -1.1 }
-    assert_nothing_raised { @item.applyProtection = false }
-    assert_equal(@item.applyProtection, false)
-  end
-
-end

data/test/tc_axlsx.rb

@@ -1,109 +0,0 @@
-require 'tc_helper.rb'
-
-class TestAxlsx < Test::Unit::TestCase
-
-  def setup_wide
-    @wide_test_points = { "A3" =>      0,
-      "Z3"    =>                      25,
-      "B3"    =>                       1,
-      "AA3"   =>             1 * 26 +  0,
-      "AAA3"  => 1 * 26**2 + 1 * 26 +  0,
-      "AAZ3"  => 1 * 26**2 + 1 * 26 + 25,
-      "ABA3"  => 1 * 26**2 + 2 * 26 +  0,
-      "BZU3"  => 2 * 26**2 + 26 * 26 + 20
-    }
-  end
-
-  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
-    # Class variables like this are not reset between test runs, so we have
-    # to save and restore the original value manually.
-    old = Axlsx.trust_input
-
-    Axlsx.trust_input = true
-    assert_equal true, Axlsx.trust_input
-
-    Axlsx.trust_input = old
-  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_cell_range_row
-    p = Axlsx::Package.new
-    ws = p.workbook.add_worksheet
-    row = ws.add_row
-    row.add_cell
-    row.add_cell
-    row.add_cell
-    assert_equal("A1:C1", Axlsx.cell_range(row, false))
-  end
-
-  def test_name_to_indices
-    setup_wide
-    @wide_test_points.each do |key, value|
-      assert_equal(Axlsx.name_to_indices(key), [value,2])
-    end
-  end
-
-  def test_col_ref
-    setup_wide
-    @wide_test_points.each do |key, value|
-      assert_equal(Axlsx.col_ref(value), key.gsub(/\d+/, ''))
-    end
-  end
-
-  def test_cell_r
-    # 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
-
-  def test_sanitize_frozen_control_strippped
-    needs_sanitize = "legit\x08".freeze # Backspace control char
-
-    assert_equal(Axlsx.sanitize(needs_sanitize), 'legit', 'should strip control chars')
-  end
-
-  def test_sanitize_unfrozen_control_strippped
-    needs_sanitize = "legit\x08" # Backspace control char
-    sanitized_str = Axlsx.sanitize(needs_sanitize)
-
-    assert_equal(sanitized_str,           'legit',                  'should strip control chars')
-    assert_equal(sanitized_str.object_id, sanitized_str.object_id,  'should preserve object')
-  end
-
-  def test_sanitize_unfrozen_no_sanitize
-    legit_str = 'legit'
-    sanitized_str = Axlsx.sanitize(legit_str)
-
-    assert_equal(sanitized_str,           legit_str,            'should preserve value')
-    assert_equal(sanitized_str.object_id, legit_str.object_id,  'should preserve object')
-  end
-end

data/test/tc_helper.rb

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