Merge branch 'master' of https://github.com/randym/axlsx

33 files changed, 332 insertions, 143 deletions

diff --git a/test/benchmark.rb b/test/benchmark.rb
index 2ef82eaf..b1162591 100644
--- a/test/benchmark.rb
+++ b/test/benchmark.rb
@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby -s
-# -*- coding: utf-8 -*-
 $:.unshift "#{File.dirname(__FILE__)}/../lib"
 require 'axlsx'
 require 'csv'
diff --git a/test/doc_props/tc_core.rb b/test/doc_props/tc_core.rb
index cfff4d59..0eddfed7 100644
--- a/test/doc_props/tc_core.rb
+++ b/test/doc_props/tc_core.rb
@@ -23,6 +23,13 @@ class TestCore < Test::Unit::TestCase
     assert_equal(@doc.xpath('//dcterms:created').text, @time, "dcterms:created incorrect")
   end
 
+  def test_created_as_option
+    time = Time.utc(2013, 1, 1, 12, 00)
+    c = Axlsx::Core.new :created => time
+    doc = Nokogiri::XML(c.to_xml_string)
+    assert_equal(doc.xpath('//dcterms:created').text, time.xmlschema, "dcterms:created incorrect")
+  end
+
   def test_populates_default_name
     assert_equal(@doc.xpath('//dc:creator').text, "axlsx", "Default name not populated")
   end
diff --git a/test/drawing/tc_axes.rb b/test/drawing/tc_axes.rb
new file mode 100644
index 00000000..e3c26936
--- /dev/null
+++ b/test/drawing/tc_axes.rb
@@ -0,0 +1,8 @@
+require 'tc_helper.rb'
+
+class TestAxes < Test::Unit::TestCase
+  def test_constructor_requires_cat_axis_first
+    assert_raise(ArgumentError) { Axlsx::Axes.new(:val_axis => Axlsx::ValAxis, :cat_axis => Axlsx::CatAxis) }
+    assert_nothing_raised { Axlsx::Axes.new(:cat_axis => Axlsx::CatAxis, :val_axis => Axlsx::ValAxis) }
+  end
+end
\ No newline at end of file
diff --git a/test/drawing/tc_axis.rb b/test/drawing/tc_axis.rb
index 807655d7..3546f786 100644
--- a/test/drawing/tc_axis.rb
+++ b/test/drawing/tc_axis.rb
@@ -2,25 +2,22 @@ require 'tc_helper.rb'
 
 class TestAxis < Test::Unit::TestCase
   def setup
-    
-    @axis = Axlsx::Axis.new 12345, 54321, :gridlines => false, :title => 'Foo'
+    @axis = Axlsx::Axis.new :gridlines => false, :title => 'Foo'
   end
 
-  def teardown
-  end
 
   def test_initialization
-    assert_equal(@axis.axPos, :b, "axis position default incorrect")
-    assert_equal(@axis.tickLblPos, :nextTo, "tick label position default incorrect")
-    assert_equal(@axis.tickLblPos, :nextTo, "tick label position default incorrect")
+    assert_equal(@axis.ax_pos, :b, "axis position default incorrect")
+    assert_equal(@axis.tick_lbl_pos, :nextTo, "tick label position default incorrect")
+    assert_equal(@axis.tick_lbl_pos, :nextTo, "tick label position default incorrect")
     assert_equal(@axis.crosses, :autoZero, "tick label position default incorrect")
     assert(@axis.scaling.is_a?(Axlsx::Scaling) && @axis.scaling.orientation == :minMax, "scaling default incorrect")
-    assert_raise(ArgumentError) { Axlsx::Axis.new( -1234, 'abcd') }
     assert_equal('Foo', @axis.title.text)
   end
 
   def test_color
     @axis.color = "00FF00"
+    @axis.cross_axis = Axlsx::CatAxis.new
     str  = '<?xml version="1.0" encoding="UTF-8"?>'
     str << '<c:chartSpace xmlns:c="' << Axlsx::XML_NS_C << '" xmlns:a="' << Axlsx::XML_NS_A << '">'
     doc = Nokogiri::XML(@axis.to_xml_string(str)) 
@@ -35,15 +32,15 @@ class TestAxis < Test::Unit::TestCase
       sheet.add_row ['cat', 7, 9, 10]
       sheet.add_chart(Axlsx::Line3DChart) do |chart|
         chart.add_series :data => sheet['B2:D2'], :labels => sheet['B1']
-        chart.valAxis.title = sheet['A1']
-        assert_equal('battle victories', chart.valAxis.title.text)  
+        chart.val_axis.title = sheet['A1']
+        assert_equal('battle victories', chart.val_axis.title.text)
       end
     end
   end
 
   def test_axis_position
-    assert_raise(ArgumentError, "requires valid axis position") { @axis.axPos = :nowhere }
-    assert_nothing_raised("accepts valid axis position") { @axis.axPos = :r }
+    assert_raise(ArgumentError, "requires valid axis position") { @axis.ax_pos = :nowhere }
+    assert_nothing_raised("accepts valid axis position") { @axis.ax_pos = :r }
   end
 
   def test_label_rotation
@@ -55,13 +52,13 @@ class TestAxis < Test::Unit::TestCase
   end
 
   def test_tick_label_position
-    assert_raise(ArgumentError, "requires valid tick label position") { @axis.tickLblPos = :nowhere }
-    assert_nothing_raised("accepts valid tick label position") { @axis.tickLblPos = :high }
+    assert_raise(ArgumentError, "requires valid tick label position") { @axis.tick_lbl_pos = :nowhere }
+    assert_nothing_raised("accepts valid tick label position") { @axis.tick_lbl_pos = :high }
   end
 
   def test_format_code
-    assert_raise(ArgumentError, "requires valid format code") { @axis.format_code = 1 }
-    assert_nothing_raised("accepts valid format code") { @axis.tickLblPos = :high }
+    assert_raise(ArgumentError, "requires valid format code") { @axis.format_code = :high }
+    assert_nothing_raised("accepts valid format code") { @axis.format_code = "00.##"  }
   end
 
   def test_crosses
@@ -75,12 +72,13 @@ class TestAxis < Test::Unit::TestCase
   end
   
   def test_to_xml_string
+    @axis.cross_axis = Axlsx::CatAxis.new
     str  = '<?xml version="1.0" encoding="UTF-8"?>'
     str << '<c:chartSpace xmlns:c="' << Axlsx::XML_NS_C << '" xmlns:a="' << Axlsx::XML_NS_A << '">'
     doc = Nokogiri::XML(@axis.to_xml_string(str)) 
     assert(doc.xpath('//a:noFill'))
     assert(doc.xpath("//c:crosses[@val='#{@axis.crosses.to_s}']"))
-    assert(doc.xpath("//c:crossAx[@val='#{@axis.crossAx.to_s}']"))
+    assert(doc.xpath("//c:crossAx[@val='#{@axis.cross_axis.to_s}']"))
     assert(doc.xpath("//a:bodyPr[@rot='#{@axis.label_rotation.to_s}']"))
     assert(doc.xpath("//a:t[text()='Foo']"))
   end
diff --git a/test/drawing/tc_bar_3D_chart.rb b/test/drawing/tc_bar_3D_chart.rb
index 3e1ff342..0cae7af6 100644
--- a/test/drawing/tc_bar_3D_chart.rb
+++ b/test/drawing/tc_bar_3D_chart.rb
@@ -62,4 +62,10 @@ class TestBar3DChart < Test::Unit::TestCase
     assert(errors.empty?, "error free validation")
   end
 
+  def test_to_xml_string_has_axes_in_correct_order
+    str = @chart.to_xml_string
+    cat_axis_position = str.index(@chart.axes[:cat_axis].id.to_s)
+    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
 end
diff --git a/test/drawing/tc_cat_axis.rb b/test/drawing/tc_cat_axis.rb
index 6529b45d..ac690336 100644
--- a/test/drawing/tc_cat_axis.rb
+++ b/test/drawing/tc_cat_axis.rb
@@ -2,15 +2,15 @@ require 'tc_helper.rb'
 
 class TestCatAxis < Test::Unit::TestCase
   def setup
-    @axis = Axlsx::CatAxis.new 12345, 54321
+    @axis = Axlsx::CatAxis.new
   end
   def teardown
   end
 
   def test_initialization
     assert_equal(@axis.auto, 1, "axis auto default incorrect")
-    assert_equal(@axis.lblAlgn, :ctr, "label align default incorrect")
-    assert_equal(@axis.lblOffset, "100", "label offset default incorrect")
+    assert_equal(@axis.lbl_algn, :ctr, "label align default incorrect")
+    assert_equal(@axis.lbl_offset, "100", "label offset default incorrect")
   end
 
   def test_auto
@@ -18,14 +18,14 @@ class TestCatAxis < Test::Unit::TestCase
     assert_nothing_raised("accepts valid auto") { @axis.auto = false }
   end
 
-  def test_lblAlgn
-    assert_raise(ArgumentError, "requires valid label alignment") { @axis.lblAlgn = :nowhere }
-    assert_nothing_raised("accepts valid label alignment") { @axis.lblAlgn = :r }
+  def test_lbl_algn
+    assert_raise(ArgumentError, "requires valid label alignment") { @axis.lbl_algn = :nowhere }
+    assert_nothing_raised("accepts valid label alignment") { @axis.lbl_algn = :r }
   end
 
-  def test_lblOffset
-    assert_raise(ArgumentError, "requires valid label offset") { @axis.lblOffset = 'foo' }
-    assert_nothing_raised("accepts valid label offset") { @axis.lblOffset = "20" }
+  def test_lbl_offset
+    assert_raise(ArgumentError, "requires valid label offset") { @axis.lbl_offset = 'foo' }
+    assert_nothing_raised("accepts valid label offset") { @axis.lbl_offset = "20" }
   end
 
 end
diff --git a/test/drawing/tc_chart.rb b/test/drawing/tc_chart.rb
index 03e4fd6f..751d2ae4 100644
--- a/test/drawing/tc_chart.rb
+++ b/test/drawing/tc_chart.rb
@@ -45,6 +45,14 @@ class TestChart < Test::Unit::TestCase
     assert_equal(false, @chart.vary_colors)
   end
 
+  def test_display_blanks_as
+    assert_equal(:gap, @chart.display_blanks_as, "default is not :gap")
+    assert_raise(ArgumentError, "did not validate possible values") { @chart.display_blanks_as = :hole }
+    assert_nothing_raised { @chart.display_blanks_as = :zero }
+    assert_nothing_raised { @chart.display_blanks_as = :span }
+    assert_equal(:span, @chart.display_blanks_as)
+  end
+
   def test_start_at
     @chart.start_at 15, 25
     assert_equal(@chart.graphic_frame.anchor.from.col, 15)
@@ -94,4 +102,10 @@ class TestChart < Test::Unit::TestCase
     assert(errors.empty?, "error free validation")
   end
 
+  def test_to_xml_string_for_display_blanks_as
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::DRAWING_XSD))
+    @chart.display_blanks_as = :span
+    doc = Nokogiri::XML(@chart.to_xml_string)
+    assert_equal("span", doc.xpath("//c:dispBlanksAs").attr("val").value, "did not use the display_blanks_as configuration")
+  end
 end
diff --git a/test/drawing/tc_drawing.rb b/test/drawing/tc_drawing.rb
index f347001f..7014f1b2 100644
--- a/test/drawing/tc_drawing.rb
+++ b/test/drawing/tc_drawing.rb
@@ -53,11 +53,6 @@ class TestDrawing < Test::Unit::TestCase
     assert_equal(@ws.drawing.rels_pn, "drawings/_rels/drawing1.xml.rels")
   end
 
-  def test_rId
-    @ws.add_chart(Axlsx::Pie3DChart)
-    assert_equal(@ws.drawing.rId, "rId1")
-  end
-
   def test_index
     @ws.add_chart(Axlsx::Pie3DChart)
     assert_equal(@ws.drawing.index, @ws.workbook.drawings.index(@ws.drawing))
diff --git a/test/drawing/tc_graphic_frame.rb b/test/drawing/tc_graphic_frame.rb
index ce4b8214..eb638489 100644
--- a/test/drawing/tc_graphic_frame.rb
+++ b/test/drawing/tc_graphic_frame.rb
@@ -17,14 +17,11 @@ class TestGraphicFrame < Test::Unit::TestCase
   end
 
   def test_rId
-    assert_equal(@frame.rId, "rId1")
-    chart = @ws.add_chart Axlsx::Chart
-    assert_equal(chart.graphic_frame.rId, "rId2")
+    assert_equal @ws.drawing.relationships.for(@chart).Id, @frame.rId
   end
 
-  def test_rId_with_image_and_chart
-    image = @ws.add_image :image_src => (File.dirname(__FILE__) + "/../../examples/image1.jpeg"), :start_at => [0,25], :width => 200, :height => 200
-    assert_equal(2, image.id)
-    assert_equal(1, @chart.index+1)
+  def test_to_xml_has_correct_rId
+    doc = Nokogiri::XML(@frame.to_xml_string)
+    assert_equal @frame.rId, doc.xpath("//c:chart", doc.collect_namespaces).first["r:id"]
   end
 end
diff --git a/test/drawing/tc_hyperlink.rb b/test/drawing/tc_hyperlink.rb
index 292f1f96..b3f204b5 100644
--- a/test/drawing/tc_hyperlink.rb
+++ b/test/drawing/tc_hyperlink.rb
@@ -51,10 +51,6 @@ class TestHyperlink < Test::Unit::TestCase
     assert_equal(@hyperlink.highlightClick, false )
   end
 
-  def test_id
-    assert_equal(@hyperlink.send(:id), 2)
-  end
-
   def test_history
     assert_nothing_raised { @hyperlink.history = false }
     assert_raise(ArgumentError) {@hyperlink.history = "bob"}
diff --git a/test/drawing/tc_line_chart.rb b/test/drawing/tc_line_chart.rb
new file mode 100644
index 00000000..83ebef97
--- /dev/null
+++ b/test/drawing/tc_line_chart.rb
@@ -0,0 +1,39 @@
+require 'tc_helper.rb'
+
+class TestLineChart < Test::Unit::TestCase
+
+  def setup
+    @p = Axlsx::Package.new
+    ws = @p.workbook.add_worksheet
+    @row = ws.add_row ["one", 1, Time.now]
+    @chart = ws.add_chart Axlsx::LineChart, :title => "fishery"
+  end
+
+  def teardown
+  end
+
+  def test_initialization
+    assert_equal(@chart.grouping, :standard, "grouping defualt incorrect")
+    assert_equal(@chart.series_type, Axlsx::LineSeries, "series type incorrect")
+    assert(@chart.cat_axis.is_a?(Axlsx::CatAxis), "category axis not created")
+    assert(@chart.val_axis.is_a?(Axlsx::ValAxis), "value access not created")
+  end
+
+ def test_grouping
+   assert_raise(ArgumentError, "require valid grouping") { @chart.grouping = :inverted }
+   assert_nothing_raised("allow valid grouping") { @chart.grouping = :stacked }
+   assert(@chart.grouping == :stacked)
+ end
+
+  def test_to_xml
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::DRAWING_XSD))
+    doc = Nokogiri::XML(@chart.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
diff --git a/test/drawing/tc_line_series.rb b/test/drawing/tc_line_series.rb
index cc62005b..866553c3 100644
--- a/test/drawing/tc_line_series.rb
+++ b/test/drawing/tc_line_series.rb
@@ -6,7 +6,7 @@ class TestLineSeries < Test::Unit::TestCase
     p = Axlsx::Package.new
     @ws = p.workbook.add_worksheet :name=>"hmmm"
     chart = @ws.add_chart Axlsx::Line3DChart, :title => "fishery"
-    @series = chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob", :color => "#FF0000"
+    @series = chart.add_series :data=>[0,1,2], :labels=>["zero", "one", "two"], :title=>"bob", :color => "#FF0000", :show_marker => true
   end
 
   def test_initialize
@@ -15,10 +15,16 @@ class TestLineSeries < Test::Unit::TestCase
     assert_equal(@series.data.class, Axlsx::NumDataSource)
 
   end
-  
+
+  def test_show_marker
+    assert_equal(true, @series.show_marker)
+    @series.show_marker = false
+    assert_equal(false, @series.show_marker)
+  end  
   def test_to_xml_string
     doc = Nokogiri::XML(@series.to_xml_string)
     assert(doc.xpath("//srgbClr[@val='#{@series.color}']"))
+    assert(doc.xpath("//marker"))
   end
   #TODO serialization testing
 end
diff --git a/test/drawing/tc_pic.rb b/test/drawing/tc_pic.rb
index a892678d..79a3194d 100644
--- a/test/drawing/tc_pic.rb
+++ b/test/drawing/tc_pic.rb
@@ -93,4 +93,10 @@ class TestPic < Test::Unit::TestCase
     assert(errors.empty?, "error free validation")
   end
 
+  def test_to_xml_has_correct_r_id
+    r_id = @image.anchor.drawing.relationships.for(@image).Id
+    doc = Nokogiri::XML(@image.anchor.drawing.to_xml_string)
+    assert_equal r_id, doc.xpath("//a:blip").first["r:embed"]
+  end
+  
 end
diff --git a/test/drawing/tc_ser_axis.rb b/test/drawing/tc_ser_axis.rb
index 2f30ceb8..7febafce 100644
--- a/test/drawing/tc_ser_axis.rb
+++ b/test/drawing/tc_ser_axis.rb
@@ -2,29 +2,30 @@ require 'tc_helper.rb'
 
 class TestSerAxis < Test::Unit::TestCase
   def setup
-    @axis = Axlsx::SerAxis.new 12345, 54321
+    @axis = Axlsx::SerAxis.new
   end
+
   def teardown
   end
 
   def test_options
-    a = Axlsx::SerAxis.new 12345, 54321, :tickLblSkip => 9, :tickMarkSkip => 7
-    assert_equal(a.tickLblSkip, 9)
-    assert_equal(a.tickMarkSkip, 7)
+    a = Axlsx::SerAxis.new(:tick_lbl_skip => 9, :tick_mark_skip => 7)
+    assert_equal(a.tick_lbl_skip, 9)
+    assert_equal(a.tick_mark_skip, 7)
   end
 
 
-  def test_tickLblSkip
-    assert_raise(ArgumentError, "requires valid tickLblSkip") { @axis.tickLblSkip = -1 }
-    assert_nothing_raised("accepts valid tickLblSkip") { @axis.tickLblSkip = 1 }
-    assert_equal(@axis.tickLblSkip, 1)
+  def test_tick_lbl_skip
+    assert_raise(ArgumentError, "requires valid tick_lbl_skip") { @axis.tick_lbl_skip = -1 }
+    assert_nothing_raised("accepts valid tick_lbl_skip") { @axis.tick_lbl_skip = 1 }
+    assert_equal(@axis.tick_lbl_skip, 1)
   end
 
 
-  def test_tickMarkSkip
-    assert_raise(ArgumentError, "requires valid tickMarkSkip") { @axis.tickMarkSkip = :my_eyes }
-    assert_nothing_raised("accepts valid tickMarkSkip") { @axis.tickMarkSkip = 2 }
-    assert_equal(@axis.tickMarkSkip, 2)
+  def test_tick_mark_skip
+    assert_raise(ArgumentError, "requires valid tick_mark_skip") { @axis.tick_mark_skip = :my_eyes }
+    assert_nothing_raised("accepts valid tick_mark_skip") { @axis.tick_mark_skip = 2 }
+    assert_equal(@axis.tick_mark_skip, 2)
   end
 
 end
diff --git a/test/drawing/tc_val_axis.rb b/test/drawing/tc_val_axis.rb
index f3f55421..aa1cb23a 100644
--- a/test/drawing/tc_val_axis.rb
+++ b/test/drawing/tc_val_axis.rb
@@ -2,23 +2,23 @@ require 'tc_helper.rb'
 
 class TestValAxis < Test::Unit::TestCase
   def setup
-    @axis = Axlsx::ValAxis.new 12345, 54321
+    @axis = Axlsx::ValAxis.new
   end
   def teardown
   end
 
   def test_initialization
-    assert_equal(@axis.crossBetween, :between, "axis crossBetween default incorrect")
+    assert_equal(@axis.cross_between, :between, "axis crossBetween default incorrect")
   end
 
   def test_options
-    a = Axlsx::ValAxis.new 2345, 4321, :crossBetween => :midCat
-    assert_equal(a.crossBetween, :midCat)
+    a = Axlsx::ValAxis.new(:cross_between => :midCat)
+    assert_equal(:midCat, a.cross_between)
   end
 
   def test_crossBetween
-    assert_raise(ArgumentError, "requires valid crossBetween") { @axis.crossBetween = :my_eyes }
-    assert_nothing_raised("accepts valid crossBetween") { @axis.crossBetween = :midCat }
+    assert_raise(ArgumentError, "requires valid crossBetween") { @axis.cross_between = :my_eyes }
+    assert_nothing_raised("accepts valid crossBetween") { @axis.cross_between = :midCat }
   end
 
 end
diff --git a/test/drawing/tc_vml_shape.rb b/test/drawing/tc_vml_shape.rb
index 719beca7..94ad6e9f 100644
--- a/test/drawing/tc_vml_shape.rb
+++ b/test/drawing/tc_vml_shape.rb
@@ -6,8 +6,8 @@ class TestVmlShape < Test::Unit::TestCase
     p = Axlsx::Package.new
     wb = p.workbook
     @ws = wb.add_worksheet
-    @ws.add_comment :ref => 'A1', :text => 'penut machine', :author => 'crank'
-    @ws.add_comment :ref => 'C3', :text => 'rust bucket', :author => 'PO'
+    @ws.add_comment :ref => 'A1', :text => 'penut machine', :author => 'crank', :visible => true
+    @ws.add_comment :ref => 'C3', :text => 'rust bucket', :author => 'PO', :visible => false
     @comments = @ws.comments
   end
 
@@ -84,11 +84,17 @@ class TestVmlShape < Test::Unit::TestCase
     assert(shape.top_row == 3)
     assert_raise(ArgumentError) { shape.top_row = [] }
   end
-
+  def test_visible
+    shape = @comments.first.vml_shape
+    shape.visible = false
+    assert(shape.visible == false)
+    assert_raise(ArgumentError) { shape.visible = 'foo' }
+  end
   def test_to_xml_string
     str = @comments.vml_drawing.to_xml_string()
     doc = Nokogiri::XML(str)
     assert_equal(doc.xpath("//v:shape").size, 2)
+    assert_equal(1, doc.xpath("//x:Visible").size, 'ClientData/x:Visible element rendering')
     @comments.each do |comment|
       shape = comment.vml_shape
       assert(doc.xpath("//v:shape/x:ClientData/x:Row[text()='#{shape.row}']").size == 1)
diff --git a/test/profile.rb b/test/profile.rb
index 8e4218fd..ffe057e4 100644
--- a/test/profile.rb
+++ b/test/profile.rb
@@ -1,26 +1,20 @@
 #!/usr/bin/env ruby -s
 
-# Usage:
-# > ruby test/profile.rb
-# > pprof.rb --gif /tmp/axlsx > /tmp/axlsx.gif
-# > open /tmp/axlsx_noautowidth.gif
-
 $:.unshift "#{File.dirname(__FILE__)}/../lib"
 require 'axlsx'
-require 'perftools'
-Axlsx.trust_input = true
+require 'ruby-prof'
 row = []
 # Taking worst case scenario of all string data
 input = (32..126).to_a.pack('U*').chars.to_a
 20.times { row << input.shuffle.join}
-times = 3000
 
-PerfTools::CpuProfiler.start("/tmp/axlsx") do
+profile = RubyProf.profile do
   p = Axlsx::Package.new
   p.workbook.add_worksheet do |sheet|
-    times.times do
+    30.times do
       sheet << row
     end
   end
-  p.serialize("example.xlsx")
 end
+printer = RubyProf::CallTreePrinter.new(profile)
+printer.print(File.new('axlsx.qcachegrind', 'w'))
diff --git a/test/rels/tc_relationship.rb b/test/rels/tc_relationship.rb
index 32b9e4a1..add1654f 100644
--- a/test/rels/tc_relationship.rb
+++ b/test/rels/tc_relationship.rb
@@ -1,26 +1,44 @@
 require 'tc_helper.rb'
 
 class TestRelationships < Test::Unit::TestCase
-  def setup
+  
+  def test_instances_with_different_attributes_have_unique_ids
+    rel_1 = Axlsx::Relationship.new(Object.new, Axlsx::WORKSHEET_R, 'target')
+    rel_2 = Axlsx::Relationship.new(Object.new, Axlsx::COMMENT_R, 'foobar')
+    assert_not_equal rel_1.Id, rel_2.Id
   end
-
-  def teardown
+  
+  def test_instances_with_same_attributes_share_id
+    source_obj = Object.new
+    instance = Axlsx::Relationship.new(source_obj, Axlsx::WORKSHEET_R, 'target')
+    assert_equal instance.Id, Axlsx::Relationship.new(source_obj, Axlsx::WORKSHEET_R, 'target').Id
   end
-
+  
+  def test_target_is_only_considered_for_same_attributes_check_if_target_mode_is_external
+    source_obj = Object.new
+    rel_1 = Axlsx::Relationship.new(source_obj, Axlsx::WORKSHEET_R, 'target')
+    rel_2 = Axlsx::Relationship.new(source_obj, Axlsx::WORKSHEET_R, '../target')
+    assert_equal rel_1.Id, rel_2.Id
+    
+    rel_3 = Axlsx::Relationship.new(source_obj, Axlsx::HYPERLINK_R, 'target', :target_mode => :External)
+    rel_4 = Axlsx::Relationship.new(source_obj, Axlsx::HYPERLINK_R, '../target', :target_mode => :External)
+    assert_not_equal rel_3.Id, rel_4.Id
+  end
+  
   def test_type
-    assert_raise(ArgumentError) { Axlsx::Relationship.new 'type', 'target' }
-    assert_nothing_raised { Axlsx::Relationship.new Axlsx::WORKSHEET_R, 'target' }
-    assert_nothing_raised { Axlsx::Relationship.new Axlsx::COMMENT_R, 'target' }
+    assert_raise(ArgumentError) { Axlsx::Relationship.new nil, 'type', 'target' }
+    assert_nothing_raised { Axlsx::Relationship.new nil, Axlsx::WORKSHEET_R, 'target' }
+    assert_nothing_raised { Axlsx::Relationship.new nil, Axlsx::COMMENT_R, 'target' }
   end
 
   def test_target_mode
-    assert_raise(ArgumentError) { Axlsx::Relationship.new 'type', 'target', :target_mode => "FISH" }
-    assert_nothing_raised { Axlsx::Relationship.new( Axlsx::WORKSHEET_R, 'target', :target_mode => :External) }
+    assert_raise(ArgumentError) { Axlsx::Relationship.new nil, 'type', 'target', :target_mode => "FISH" }
+    assert_nothing_raised { Axlsx::Relationship.new( nil, Axlsx::WORKSHEET_R, 'target', :target_mode => :External) }
   end
 
   def test_ampersand_escaping_in_target
-    r = Axlsx::Relationship.new(Axlsx::HYPERLINK_R, "http://example.com?foo=1&bar=2", :target_mod => :External)
-    doc = Nokogiri::XML(r.to_xml_string(1))
+    r = Axlsx::Relationship.new(nil, Axlsx::HYPERLINK_R, "http://example.com?foo=1&bar=2", :target_mod => :External)
+    doc = Nokogiri::XML(r.to_xml_string)
     assert_equal(doc.xpath("//Relationship[@Target='http://example.com?foo=1&bar=2']").size, 1)
   end
 end
diff --git a/test/rels/tc_relationships.rb b/test/rels/tc_relationships.rb
index 356e4691..fe5a1ce5 100644
--- a/test/rels/tc_relationships.rb
+++ b/test/rels/tc_relationships.rb
@@ -2,6 +2,17 @@ require 'tc_helper.rb'
 
 class TestRelationships < Test::Unit::TestCase
 
+  def test_for
+    source_obj_1, source_obj_2 = Object.new, Object.new
+    rel_1 = Axlsx::Relationship.new(source_obj_1, Axlsx::WORKSHEET_R, "bar")
+    rel_2 = Axlsx::Relationship.new(source_obj_2, Axlsx::WORKSHEET_R, "bar")
+    rels = Axlsx::Relationships.new
+    rels << rel_1 
+    rels << rel_2
+    assert_equal rel_1, rels.for(source_obj_1)
+    assert_equal rel_2, rels.for(source_obj_2)
+  end
+  
   def test_valid_document
     @rels = Axlsx::Relationships.new
     schema = Nokogiri::XML::Schema(File.open(Axlsx::RELS_XSD))
@@ -12,7 +23,7 @@ class TestRelationships < Test::Unit::TestCase
       errors << error
     end
 
-    @rels << Axlsx::Relationship.new(Axlsx::WORKSHEET_R, "bar")
+    @rels << Axlsx::Relationship.new(nil, Axlsx::WORKSHEET_R, "bar")
     doc = Nokogiri::XML(@rels.to_xml_string)
     errors = []
     schema.validate(doc).each do |error|
diff --git a/test/stylesheet/tc_styles.rb b/test/stylesheet/tc_styles.rb
index b9d0b28a..98c8e3ef 100644
--- a/test/stylesheet/tc_styles.rb
+++ b/test/stylesheet/tc_styles.rb
@@ -150,7 +150,7 @@ class TestStyles < Test::Unit::TestCase
     assert_equal(@styles.parse_fill_options(:bg_color => "DE").class, Fixnum, "return index of fill if not :dxf type")
     assert_equal(@styles.parse_fill_options(:bg_color => "DE", :type => :dxf).class, Axlsx::Fill, "return fill object if :dxf type")
     f = @styles.parse_fill_options(:bg_color => "DE", :type => :dxf)
-    assert(f.fill_type.fgColor.rgb == "FFDEDEDE")
+    assert(f.fill_type.bgColor.rgb == "FFDEDEDE")
   end
 
   def test_parse_protection_options
@@ -210,7 +210,7 @@ class TestStyles < Test::Unit::TestCase
     assert_equal(0, style, "returns the zero-based dxfId")
 
     dxf = @styles.dxfs.last
-    assert_equal(@styles.dxfs.last.fill.fill_type.fgColor.rgb, "FF000000", "fill created with color")
+    assert_equal(@styles.dxfs.last.fill.fill_type.bgColor.rgb, "FF000000", "fill created with color")
 
     assert_equal(font_count, (@styles.fonts.size), "font not created under styles")
     assert_equal(fill_count, (@styles.fills.size), "fill not created under styles")
diff --git a/test/tc_helper.rb b/test/tc_helper.rb
index 34f7f22d..af40a1e4 100644
--- a/test/tc_helper.rb
+++ b/test/tc_helper.rb
@@ -2,7 +2,9 @@ $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"
diff --git a/test/tc_package.rb b/test/tc_package.rb
index 5fd411e0..833f36b1 100644
--- a/test/tc_package.rb
+++ b/test/tc_package.rb
@@ -105,6 +105,12 @@ class TestPackage < Test::Unit::TestCase
     assert(Axlsx::Package.new.workbook.worksheets.size == 0, 'Workbook should not have sheets by default')
   end
 
+  def test_created_at_is_propagated_to_core
+    time = Time.utc(2013, 1, 1, 12, 0)
+    p = Axlsx::Package.new :created_at => time
+    assert_equal(time, p.core.created)
+  end
+
   def test_serialization
     assert_nothing_raised do
       begin
@@ -117,6 +123,27 @@ class TestPackage < Test::Unit::TestCase
       end
     end
   end
+  
+  # See comment for Package#zip_entry_for_part
+  def test_serialization_creates_identical_files_at_any_time_if_created_at_is_set
+    @package.core.created = Time.now
+    zip_content_now = @package.to_stream.string
+    Timecop.travel(3600) do
+      zip_content_then = @package.to_stream.string
+      assert zip_content_then == zip_content_now, "zip files are not identical"
+    end
+  end
+  
+  def test_serialization_creates_identical_files_for_identical_packages
+    package_1, package_2 = 2.times.map do 
+      Axlsx::Package.new(:created_at => Time.utc(2013, 1, 1)).tap do |p|
+        p.workbook.add_worksheet(:name => "Basic Worksheet") do |sheet|
+          sheet.add_row [1, 2, 3]
+        end
+      end
+    end
+    assert package_1.to_stream.string == package_2.to_stream.string, "zip files are not identical"
+  end
 
   def test_validation
     assert_equal(@package.validate.size, 0, @package.validate)
diff --git a/test/util/tc_validators.rb b/test/util/tc_validators.rb
index de896f3d..7a82f90d 100644
--- a/test/util/tc_validators.rb
+++ b/test/util/tc_validators.rb
@@ -158,7 +158,11 @@ class TestValidators < Test::Unit::TestCase
     assert_raise(ArgumentError) { Axlsx.validate_split_state_type 'frozen_split' }
     assert_raise(ArgumentError) { Axlsx.validate_split_state_type 0 }
   end
-
+ 
+  def test_validate_integerish
+    assert_raise(ArgumentError) { Axlsx.validate_integerish Axlsx }
+    [1, 1.4, "a"].each { |test_value| assert_nothing_raised { Axlsx.validate_integerish test_value } }
+  end
   def test_validate_family
     assert_raise(ArgumentError) { Axlsx.validate_family 0 }
     (1..5).each do |item|
diff --git a/test/workbook/tc_shared_strings_table.rb b/test/workbook/tc_shared_strings_table.rb
index e3c9bf7b..7a333f4f 100644
--- a/test/workbook/tc_shared_strings_table.rb
+++ b/test/workbook/tc_shared_strings_table.rb
@@ -24,6 +24,12 @@ class TestSharedStringsTable < Test::Unit::TestCase
     assert_equal(sst.unique_count, 4)
   end
 
+  def test_uses_workbook_xml_space
+    assert_equal(@p.workbook.xml_space, @p.workbook.shared_strings.xml_space)
+    @p.workbook.xml_space = :default
+    assert_equal(:default, @p.workbook.shared_strings.xml_space)
+  end
+
   def test_valid_document
     schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
     doc = Nokogiri::XML(@p.workbook.shared_strings.to_xml_string)
diff --git a/test/workbook/tc_workbook.rb b/test/workbook/tc_workbook.rb
index 1a9b9669..32b6935a 100644
--- a/test/workbook/tc_workbook.rb
+++ b/test/workbook/tc_workbook.rb
@@ -9,6 +9,23 @@ class TestWorkbook < Test::Unit::TestCase
   def teardown
   end
 
+  def test_worksheet_users_xml_space
+    sheet = @wb.add_worksheet(:name => 'foo')
+    ws_xml = Nokogiri::XML(sheet.to_xml_string)
+    assert(ws_xml.xpath("//xmlns:worksheet/@xml:space='preserve'"))
+
+    @wb.xml_space = :default
+    ws_xml = Nokogiri::XML(sheet.to_xml_string)
+    assert(ws_xml.xpath("//xmlns:worksheet/@xml:space='default'"))
+  end
+
+  def test_xml_space
+    assert_equal(:preserve, @wb.xml_space)
+    @wb.xml_space = :default
+    assert_equal(:default, @wb.xml_space)
+    assert_raise(ArgumentError) { @wb.xml_space = :none }
+  end
+
   def test_no_autowidth
     assert_equal(@wb.use_autowidth, true)
     assert_raise(ArgumentError) {@wb.use_autowidth = 0.1}
@@ -99,5 +116,10 @@ class TestWorkbook < Test::Unit::TestCase
     assert_equal(doc.xpath('//xmlns:workbook/xmlns:definedNames/xmlns:definedName').inner_text, @wb.worksheets[0].auto_filter.defined_name)
   end
 
-
+  def test_to_xml_uses_correct_rIds_for_pivotCache
+    ws = @wb.add_worksheet
+    pivot_table = ws.add_pivot_table('G5:G6', 'A1:D5')
+    doc = Nokogiri::XML(@wb.to_xml_string)
+    assert_equal pivot_table.cache_definition.rId, doc.xpath("//xmlns:pivotCache").first["r:id"]
+  end
 end
diff --git a/test/workbook/worksheet/tc_comment.rb b/test/workbook/worksheet/tc_comment.rb
index 0cb79bcc..e66abb9a 100644
--- a/test/workbook/worksheet/tc_comment.rb
+++ b/test/workbook/worksheet/tc_comment.rb
@@ -5,7 +5,7 @@ class TestComment < Test::Unit::TestCase
     p = Axlsx::Package.new
     wb = p.workbook
     @ws = wb.add_worksheet
-    @c1 = @ws.add_comment :ref => 'A1', :text => 'penut machine', :author => 'crank'
+    @c1 = @ws.add_comment :ref => 'A1', :text => 'text with special char <', :author => 'author with special char <', :visible => false
     @c2 = @ws.add_comment :ref => 'C3', :text => 'rust bucket', :author => 'PO'
   end
 
@@ -14,12 +14,12 @@ class TestComment < Test::Unit::TestCase
   end
 
   def test_author
-    assert(@c1.author == 'crank')
+    assert(@c1.author == 'author with special char <')
     assert(@c2.author == 'PO')
   end
 
   def test_text
-    assert(@c1.text == 'penut machine')
+    assert(@c1.text == 'text with special char <')
     assert(@c2.text == 'rust bucket')
   end
 
@@ -28,6 +28,10 @@ class TestComment < Test::Unit::TestCase
     assert_equal(@c2.author_index, 0)
   end
 
+  def test_visible
+    assert_equal(false, @c1.visible)
+    assert_equal(true, @c2.visible)
+  end
   def test_ref
     assert(@c1.ref == 'A1')
     assert(@c2.ref == 'C3')
@@ -45,13 +49,24 @@ class TestComment < Test::Unit::TestCase
     assert(@c1.vml_shape.bottom_row == pos[1]+4)
   end
 
-  def to_xml_string
+  def test_to_xml_string
     doc = Nokogiri::XML(@c1.to_xml_string)
     assert_equal(doc.xpath("//comment[@ref='#{@c1.ref}']").size, 1)
-    assert_equal(doc.xpath("//comment[@authorId='#{@c1.author_index.to}']").size, 1)
-    assert_equal(doc.xpath("//t[text()='#{@c1.author}']").size, 1)
+    assert_equal(doc.xpath("//comment[@authorId='#{@c1.author_index.to_s}']").size, 1)
+    assert_equal(doc.xpath("//t[text()='#{@c1.author}:\n']").size, 1)
     assert_equal(doc.xpath("//t[text()='#{@c1.text}']").size, 1)
   end
 
+  def test_comment_text_contain_author_and_text
+    comment = @ws.add_comment :ref => 'C4', :text => 'some text', :author => 'Bob'
+    doc = Nokogiri::XML(comment.to_xml_string)
+    assert_equal("Bob:\nsome text", doc.xpath("//comment/text").text)
+  end
+
+  def test_comment_text_does_not_contain_stray_colon_if_author_blank
+    comment = @ws.add_comment :ref => 'C5', :text => 'some text', :author => ''
+    doc = Nokogiri::XML(comment.to_xml_string)
+    assert_equal("some text", doc.xpath("//comment/text").text)
+  end
 end
 
diff --git a/test/workbook/worksheet/tc_comments.rb b/test/workbook/worksheet/tc_comments.rb
index 665f3598..acadf73d 100644
--- a/test/workbook/worksheet/tc_comments.rb
+++ b/test/workbook/worksheet/tc_comments.rb
@@ -25,9 +25,9 @@ class TestComments < Test::Unit::TestCase
   end
   def test_authors
     assert_equal(@ws.comments.authors.size, @ws.comments.size)
-    @ws.add_comment(:text => 'Yes We Can!', :author => :bob, :ref => 'F1')
+    @ws.add_comment(:text => 'Yes We Can!', :author => 'bob', :ref => 'F1')
     assert_equal(@ws.comments.authors.size, 3)
-    @ws.add_comment(:text => 'Yes We Can!', :author => :bob, :ref => 'F1')
+    @ws.add_comment(:text => 'Yes We Can!', :author => 'bob', :ref => 'F1')
     assert_equal(@ws.comments.authors.size, 3, 'only unique authors are returned') 
   end
   def test_pn
diff --git a/test/workbook/worksheet/tc_conditional_formatting.rb b/test/workbook/worksheet/tc_conditional_formatting.rb
index 087fd40e..9e5e01cf 100644
--- a/test/workbook/worksheet/tc_conditional_formatting.rb
+++ b/test/workbook/worksheet/tc_conditional_formatting.rb
@@ -130,6 +130,15 @@ class TestConditionalFormatting < Test::Unit::TestCase
     assert doc.xpath("//xmlns:worksheet/xmlns:conditionalFormatting//xmlns:cfRule[@type='cellIs'][@dxfId=0][@priority=1][@operator='greaterThan']//xmlns:formula='0.5'")
   end
 
+  def test_multiple_formulas
+    @ws.add_conditional_formatting "B3:B3", { :type => :cellIs, :dxfId => 0, :priority => 1, :operator => :between, :formula => ["1 <> 2","5"] }
+    doc = Nokogiri::XML.parse(@ws.to_xml_string)
+    p doc.xpath("//xmlns:worksheet/xmlns:conditionalFormatting//xmlns:cfRule[@type='cellIs'][@dxfId=0][@priority=1][@operator='between']")
+
+    assert doc.xpath("//xmlns:worksheet/xmlns:conditionalFormatting//xmlns:cfRule[@type='cellIs'][@dxfId=0][@priority=1][@operator='between']//xmlns:formula='1 <> 2'")
+    assert doc.xpath("//xmlns:worksheet/xmlns:conditionalFormatting//xmlns:cfRule[@type='cellIs'][@dxfId=0][@priority=1][@operator='between']//xmlns:formula='5'")
+  end
+
   def test_sqref
     assert_raise(ArgumentError) { @cf.sqref = 10 }
     assert_nothing_raised { @cf.sqref = "A1:A1" }
diff --git a/test/workbook/worksheet/tc_pivot_table.rb b/test/workbook/worksheet/tc_pivot_table.rb
index 9adbaf93..ee90bec2 100644
--- a/test/workbook/worksheet/tc_pivot_table.rb
+++ b/test/workbook/worksheet/tc_pivot_table.rb
@@ -1,5 +1,17 @@
 require 'tc_helper.rb'
 
+
+def shared_test_pivot_table_xml_validity(pivot_table)
+  schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+  doc = Nokogiri::XML(pivot_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
+
 class TestPivotTable < Test::Unit::TestCase
   def setup
     p = Axlsx::Package.new
@@ -33,10 +45,17 @@ class TestPivotTable < Test::Unit::TestCase
     end
     assert_equal(['Year', 'Month'], pivot_table.rows)
     assert_equal(['Type'], pivot_table.columns)
-    assert_equal(['Sales'], pivot_table.data)
+    assert_equal([{:ref=>"Sales"}], pivot_table.data)
     assert_equal(['Region'], pivot_table.pages)
   end
 
+  def test_add_pivot_table_with_options_on_data_field
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:D5') do |pt|
+      pt.data = [{:ref=>"Sales", :subtotal => 'average'}]
+    end
+    assert_equal([{:ref=>"Sales", :subtotal => 'average'}], pivot_table.data)
+  end
+
   def test_header_indices
     pivot_table = @ws.add_pivot_table('G5:G6', 'A1:E5')
     assert_equal(0,   pivot_table.header_index_of('Year'   ))
@@ -53,11 +72,6 @@ class TestPivotTable < Test::Unit::TestCase
     assert_equal(@ws.pivot_tables.first.pn, "pivotTables/pivotTable1.xml")
   end
 
-  def test_rId
-    @ws.add_pivot_table('G5:G6', 'A1:D5')
-    assert_equal(@ws.pivot_tables.first.rId, "rId1")
-  end
-
   def test_index
     @ws.add_pivot_table('G5:G6', 'A1:D5')
     assert_equal(@ws.pivot_tables.first.index, @ws.workbook.pivot_tables.index(@ws.pivot_tables.first))
@@ -73,14 +87,7 @@ class TestPivotTable < Test::Unit::TestCase
 
   def test_to_xml_string
     pivot_table = @ws.add_pivot_table('G5:G6', 'A1:D5')
-    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
-    doc = Nokogiri::XML(pivot_table.to_xml_string)
-    errors = []
-    schema.validate(doc).each do |error|
-      errors.push error
-      puts error.message
-    end
-    assert(errors.empty?, "error free validation")
+    shared_test_pivot_table_xml_validity(pivot_table)
   end
 
   def test_to_xml_string_with_configuration
@@ -90,13 +97,13 @@ class TestPivotTable < Test::Unit::TestCase
       pt.data = ['Sales']
       pt.pages = ['Region']
     end
-    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
-    doc = Nokogiri::XML(pivot_table.to_xml_string)
-    errors = []
-    schema.validate(doc).each do |error|
-      errors.push error
-      puts error.message
+    shared_test_pivot_table_xml_validity(pivot_table)
+  end
+
+  def test_to_xml_string_with_options_on_data_field
+    pivot_table = @ws.add_pivot_table('G5:G6', 'A1:E5') do |pt|
+      pt.data = [{:ref=>"Sales", :subtotal => 'average'}]
     end
-    assert(errors.empty?, "error free validation")
+    shared_test_pivot_table_xml_validity(pivot_table)
   end
 end
diff --git a/test/workbook/worksheet/tc_pivot_table_cache_definition.rb b/test/workbook/worksheet/tc_pivot_table_cache_definition.rb
index 2b4389b7..a38e808a 100644
--- a/test/workbook/worksheet/tc_pivot_table_cache_definition.rb
+++ b/test/workbook/worksheet/tc_pivot_table_cache_definition.rb
@@ -21,7 +21,7 @@ class TestPivotTableCacheDefinition < Test::Unit::TestCase
   end
 
   def test_rId
-    assert_equal('rId1', @cache_definition.rId)
+    assert_equal @pivot_table.relationships.for(@cache_definition).Id, @cache_definition.rId
   end
 
   def test_index
diff --git a/test/workbook/worksheet/tc_table.rb b/test/workbook/worksheet/tc_table.rb
index de86b886..6f39bb13 100644
--- a/test/workbook/worksheet/tc_table.rb
+++ b/test/workbook/worksheet/tc_table.rb
@@ -36,8 +36,8 @@ class TestTable < Test::Unit::TestCase
   end
 
   def test_rId
-    @ws.add_table("A1:D5")
-    assert_equal(@ws.tables.first.rId, "rId1")
+    table = @ws.add_table("A1:D5")
+    assert_equal @ws.relationships.for(table).Id, table.rId
   end
 
   def test_index
diff --git a/test/workbook/worksheet/tc_worksheet.rb b/test/workbook/worksheet/tc_worksheet.rb
index ed8c7cab..00983fec 100644
--- a/test/workbook/worksheet/tc_worksheet.rb
+++ b/test/workbook/worksheet/tc_worksheet.rb
@@ -123,9 +123,7 @@ class TestWorksheet < Test::Unit::TestCase
   end
 
   def test_rId
-    assert_equal(@ws.rId, "rId1")
-    ws = @ws.workbook.add_worksheet
-    assert_equal(ws.rId, "rId2")
+    assert_equal @ws.workbook.relationships.for(@ws).Id, @ws.rId
   end
 
   def test_index
@@ -205,13 +203,20 @@ class TestWorksheet < Test::Unit::TestCase
   def test_cols
     @ws.add_row [1,2,3,4]
     @ws.add_row [1,2,3,4]
-    @ws.add_row [1,2,3,4]
+    @ws.add_row [1,2,3]
     @ws.add_row [1,2,3,4]
     c = @ws.cols[1]
     assert_equal(c.size, 4)
     assert_equal(c[0].value, 2)
   end
 
+  def test_cols_with_block
+    @ws.add_row [1,2,3]
+    @ws.add_row [1]
+    cols = @ws.cols {|row, column| :foo }
+    assert_equal(:foo, cols[1][1])
+  end
+
   def test_row_style
     @ws.add_row [1,2,3,4]
     @ws.add_row [1,2,3,4]
@@ -334,16 +339,16 @@ class TestWorksheet < Test::Unit::TestCase
   def test_to_xml_string_drawing
     @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)
+    assert_equal @ws.send(:worksheet_drawing).relationship.Id, doc.xpath('//xmlns:worksheet/xmlns:drawing').first["r:id"]
   end
 
   def test_to_xml_string_tables
     @ws.add_row ["one", "two"]
     @ws.add_row [1, 2]
-    @ws.add_table "A1:B2"
+    table = @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)
+    assert_equal table.rId, doc.xpath('//xmlns:worksheet/xmlns:tableParts/xmlns:tablePart').first["r:id"]
   end
 
   def test_to_xml_string
diff --git a/test/workbook/worksheet/tc_worksheet_hyperlink.rb b/test/workbook/worksheet/tc_worksheet_hyperlink.rb
index 278c5add..748082ac 100644
--- a/test/workbook/worksheet/tc_worksheet_hyperlink.rb
+++ b/test/workbook/worksheet/tc_worksheet_hyperlink.rb
@@ -32,22 +32,13 @@ class TestWorksheetHyperlink < Test::Unit::TestCase
     assert_equal(@options[:ref], @a.ref)
   end
 
-  def test_id
-    @a.target = :external
-
-    assert_equal("rId1", @a.id)
-    @a.target = :internal
-    assert_equal(nil, @a.id)
-  end
-
-
   def test_to_xml_string_with_non_external
     doc = Nokogiri::XML(@ws.to_xml_string)
     assert_equal(doc.xpath("//xmlns:hyperlink[@ref='#{@a.ref}']").size, 1)
     assert_equal(doc.xpath("//xmlns:hyperlink[@tooltip='#{@a.tooltip}']").size, 1)
     assert_equal(doc.xpath("//xmlns:hyperlink[@location='#{@a.location}']").size, 1)
     assert_equal(doc.xpath("//xmlns:hyperlink[@display='#{@a.display}']").size, 1)
-    assert_equal(doc.xpath("//xmlns:hyperlink[@r:id='#{@a.id}']").size, 0)
+    assert_equal(doc.xpath("//xmlns:hyperlink[@r:id]").size, 0)
   end
 
   def test_to_xml_stirng_with_external
@@ -57,7 +48,7 @@ class TestWorksheetHyperlink < Test::Unit::TestCase
     assert_equal(doc.xpath("//xmlns:hyperlink[@tooltip='#{@a.tooltip}']").size, 1)
     assert_equal(doc.xpath("//xmlns:hyperlink[@display='#{@a.display}']").size, 1)
     assert_equal(doc.xpath("//xmlns:hyperlink[@location='#{@a.location}']").size, 0)
-    assert_equal(doc.xpath("//xmlns:hyperlink[@r:id='#{@a.id}']").size, 1)
+    assert_equal(doc.xpath("//xmlns:hyperlink[@r:id='#{@a.relationship.Id}']").size, 1)
   end
 end