axlsx 1.2.0 → 1.3.3

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

@@ -0,0 +1,79 @@
+module Axlsx
+
+  # A worksheet hyperlink object. Note that this is not the same as a drawing hyperlink object.
+  class WorksheetHyperlink
+
+    include Axlsx::OptionsParser
+    include Axlsx::Accessors
+    include Axlsx::SerializedAttributes
+    # Creates a new hyperlink object.
+    # @note the preferred way to add hyperlinks to your worksheet is the Worksheet#add_hyperlink method
+    # @param [Worksheet] worksheet the Worksheet that owns this hyperlink
+    # @param [Hash] options options to use when creating this hyperlink
+    # @option [String] display Display string, if different from string in string table. This is a property on the hyperlink object, but does not need to appear in the spreadsheet application UI.
+    # @option [String] location Location within target. If target is a workbook (or this workbook) this shall refer to a sheet and cell or a defined name. Can also be an HTML anchor if target is HTML file.
+    # @option [String] tooltip The tip to display when the user positions the mouse cursor over this hyperlink
+    # @option [Symbol] target This is :external by default. If you set it to anything else, the location is interpreted to be the current workbook.
+    # @option [String|Cell] ref The location of this hyperlink in the worksheet
+    def initialize(worksheet, options={})
+      DataTypeValidator.validate "Hyperlink.worksheet", [Worksheet], worksheet
+      @worksheet = worksheet
+      @target = :external
+      parse_options options
+      yield self if block_given?
+    end
+
+    string_attr_accessor :display, :location, :tooltip
+
+    serializable_attributes :display, :tooltip, :ref
+
+    #Cell location of hyperlink on worksheet.
+    # @return [String]
+    attr_reader :ref
+
+    # Sets the target for this hyperlink. Anything other than :external instructs the library to treat the location as an in-workbook reference.
+    # @param [Symbol] target
+    def target=(target)
+      @target = target
+    end
+
+    # Sets the cell location of this hyperlink in the worksheet
+    # @param [String|Cell] cell_reference The string reference or cell that defines where this hyperlink shows in the worksheet.
+    def ref=(cell_reference)
+      cell_reference = cell_reference.r if cell_reference.is_a?(Cell)
+      Axlsx::validate_string cell_reference
+      @ref = cell_reference
+    end
+
+       # The relationship required by this hyperlink when the taget is :external
+    # @return [Relationship]
+    def relationship
+      return unless @target == :external
+      Relationship.new HYPERLINK_R, location, :target_mode => :External
+    end
+
+    # The id of the relationship for this object
+    # @return [String]
+    def id
+      return unless @target == :external
+      "rId#{(@worksheet.relationships_index_of(self)+1)}"
+    end
+
+    # Seralize the object
+    # @param [String] str
+    # @return [String]
+    def to_xml_string(str='')
+      str << '<hyperlink '
+      serialized_attributes str, location_or_id
+      str << '/>'
+    end
+
+    # The values to be used in serialization based on the target.
+    # location should only be specified for non-external targets.
+    # r:id should only be specified for external targets.
+    # @return [Hash]
+    def location_or_id
+      @target == :external ?  { :"r:id" => id } : { :location => location }
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Axlsx
+
+  #A collection of hyperlink objects for a worksheet
+  class WorksheetHyperlinks < SimpleTypedList
+
+    # Creates a new Hyperlinks collection
+    # @param [Worksheet] worksheet the worksheet that owns these hyperlinks
+    def initialize(worksheet)
+      DataTypeValidator.validate "Hyperlinks.worksheet", [Worksheet], worksheet
+      @worksheet = worksheet
+      super WorksheetHyperlink
+    end
+
+    # Creates and adds a new hyperlink based on the options provided
+    # @see WorksheetHyperlink#initialize
+    # @return [WorksheetHyperlink]
+    def add(options)
+      @list << WorksheetHyperlink.new(@worksheet, options)
+      @list.last
+    end
+
+    # The relationships required by this collection's hyperlinks
+    # @return Array
+    def relationships
+      return [] if empty?
+      map { |hyperlink| hyperlink.relationship }
+    end
+
+    # seralize the collection of hyperlinks
+    # @return [String]
+    def to_xml_string(str='')
+      return if empty?
+      str << '<hyperlinks>'
+      @list.each { |hyperlink| hyperlink.to_xml_string(str) }
+      str << '</hyperlinks>'
+    end
+  end
+end

data/lib/axlsx.rb

@@ -5,7 +5,9 @@ require 'axlsx/version.rb'
 require 'axlsx/util/simple_typed_list.rb'
 require 'axlsx/util/constants.rb'
 require 'axlsx/util/validators.rb'
-
+require 'axlsx/util/accessors.rb'
+require 'axlsx/util/serialized_attributes'
+require 'axlsx/util/options_parser'
 # to be included with parsable intitites.
 #require 'axlsx/util/parser.rb'
 
@@ -37,15 +39,25 @@ if !Object.respond_to?(:instance_values)
   end
 end
 
-# xlsx generation with charts, images, automated column width, customizable styles and full schema validation. Axlsx excels at helping you generate beautiful Office Open XML Spreadsheet documents without having to understand the entire ECMA specification. Check out the README for some examples of how easy it is. Best of all, you can validate your xlsx file before serialization so you know for sure that anything generated is going to load on your client's machine.
+# xlsx generation with charts, images, automated column width, customizable styles
+# and full schema validation. Axlsx excels at helping you generate beautiful
+# Office Open XML Spreadsheet documents without having to understand the entire
+# ECMA specification. Check out the README for some examples of how easy it is.
+# Best of all, you can validate your xlsx file before serialization so you know
+# for sure that anything generated is going to load on your client's machine.
 module Axlsx
 
   # determines the cell range for the items provided
   def self.cell_range(cells, absolute=true)
     return "" unless cells.first.is_a? Cell
-    sort_cells(cells)
+    cells = sort_cells(cells)
     reference = "#{cells.first.reference(absolute)}:#{cells.last.reference(absolute)}"
-    absolute ? "'#{cells.first.row.worksheet.name}'!#{reference}" : reference
+    if absolute
+      escaped_name = cells.first.row.worksheet.name.gsub "'", "''"
+      "'#{escaped_name}'!#{reference}"
+    else
+      reference
+    end
   end
 
   # sorts the array of cells provided to start from the minimum x,y to
@@ -61,10 +73,11 @@ module Axlsx
   def self.coder
     @@coder ||= ::HTMLEntities.new
   end
-  
+
   # returns the x, y position of a cell
   def self.name_to_indices(name)
     raise ArgumentError, 'invalid cell name' unless name.size > 1
+    # capitalization?!?
     v = name[/[A-Z]+/].reverse.chars.reduce({:base=>1, :i=>0}) do  |val, c|
       val[:i] += ((c.bytes.first - 64) * val[:base]); val[:base] *= 26; val
     end
@@ -95,6 +108,7 @@ module Axlsx
   # @param [String] s The snake case string to camelize
   # @return [String]
   def self.camel(s="", all_caps = true)
+    s = s.to_s
     s = s.capitalize if all_caps
     s.gsub(/_(.)/){ $1.upcase }
   end

data/test/content_type/tc_default.rb

@@ -3,14 +3,6 @@ require 'tc_helper.rb'
 
 class TestDefault < Test::Unit::TestCase
 
-  def test_initialization_requires_Extension_and_ContentType
-    assert_raise(ArgumentError, "raises argument error if Extension and/or ContentType are not specified") { Axlsx::Default.new }
-    assert_raise(ArgumentError, "raises argument error if Extension and/or ContentType are not specified") { Axlsx::Default.new :Extension=>"xml" }
-    assert_raise(ArgumentError, "raises argument error if Extension and/or ContentType are not specified") { Axlsx::Default.new :ContentType=>"asdf" }
-
-    assert_nothing_raised {Axlsx::Default.new :Extension=>"foo", :ContentType=>Axlsx::XML_CT}
-
-  end
   def test_content_type_restriction
     assert_raise(ArgumentError, "raises argument error if invlalid ContentType is") { Axlsx::Default.new :ContentType=>"asdf" }
   end
@@ -20,8 +12,5 @@ class TestDefault < Test::Unit::TestCase
     doc = Nokogiri::XML(type.to_xml_string)
     assert_equal(doc.xpath("Default[@ContentType='#{Axlsx::XML_CT}']").size, 1)
     assert_equal(doc.xpath("Default[@Extension='xml']").size, 1)
-
   end
-
-
 end

data/test/content_type/tc_override.rb

@@ -1,16 +1,6 @@
-# -*- coding: utf-8 -*-
 require 'tc_helper.rb'
-
 class TestOverride < Test::Unit::TestCase
 
-  def test_initialization_requires_Extension_and_ContentType
-    err = "requires PartName and ContentType options"
-    assert_raise(ArgumentError, err) { Axlsx::Override.new }
-    assert_raise(ArgumentError, err) { Axlsx::Override.new :PartName=>"xml" }
-    assert_raise(ArgumentError, err) { Axlsx::Override.new :ContentType=>"asdf" }
-    assert_nothing_raised {Axlsx::Override.new :PartName=>"foo", :ContentType=>Axlsx::CHART_CT}
-  end
-
   def test_content_type_restriction
     assert_raise(ArgumentError, "requires known content type") { Axlsx::Override.new :ContentType=>"asdf" }
   end
@@ -20,8 +10,5 @@ class TestOverride < Test::Unit::TestCase
     doc = Nokogiri::XML(type.to_xml_string)
     assert_equal(doc.xpath("Override[@ContentType='#{Axlsx::CHART_CT}']").size, 1)
     assert_equal(doc.xpath("Override[@PartName='somechart.xml']").size, 1)
-
   end
-
-
 end

data/test/drawing/tc_d_lbls.rb

@@ -4,19 +4,29 @@ class TestDLbls < Test::Unit::TestCase
 
   def setup
     @d_lbls = Axlsx::DLbls.new(Axlsx::Pie3DChart)
+    @boolean_attributes =[:show_legend_key, 
+                          :show_val, 
+                          :show_cat_name, 
+                          :show_ser_name, 
+                          :show_percent, 
+                          :show_bubble_size, 
+                          :show_leader_lines]
   end
 
   def test_initialization
     assert_equal(:bestFit, @d_lbls.d_lbl_pos)
-    Axlsx::DLbls::BOOLEAN_ATTRIBUTES.each do |attr|
+    @boolean_attributes.each do |attr|
       assert_equal(false, @d_lbls.send(attr))
     end
   end
 
   def test_initialization_with_optoins
-    options_hash = Hash[*[Axlsx::DLbls::BOOLEAN_ATTRIBUTES.map { |name| [name, true] }] ]
+    
+    options_hash = Hash[*[@boolean_attributes.map { |name| [name, true] }] ]
+
     d_lbls = Axlsx::DLbls.new(Axlsx::Pie3DChart, options_hash.merge( { :d_lbl_pos => :t }))
-    Axlsx::DLbls::BOOLEAN_ATTRIBUTES.each do |attr|
+   
+    @boolean_attributes.each do |attr|
       assert_equal(true, d_lbls.send(attr), "boolean attributes set by options")
     end
     assert_equal(:t, d_lbls.d_lbl_pos, "d_lbl_pos set by options")
@@ -27,7 +37,7 @@ class TestDLbls < Test::Unit::TestCase
   end
 
   def test_boolean_attributes
-    Axlsx::DLbls::BOOLEAN_ATTRIBUTES.each do |attr|
+    @boolean_attributes.each do |attr|
       assert_raise(ArgumentError, "rejects non boolean value for #{attr}") { @d_lbls.send("#{attr}=", :foo) }
       assert_nothing_raised("accepts boolean value for #{attr}") { @d_lbls.send("#{attr}=", true) }
       assert_nothing_raised("accepts boolean value for #{attr}") { @d_lbls.send("#{attr}=", false) }

data/test/stylesheet/tc_styles.rb

@@ -105,6 +105,19 @@ class TestStyles < Test::Unit::TestCase
     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",

data/test/tc_axlsx.rb

@@ -14,8 +14,26 @@ class TestAxlsx < Test::Unit::TestCase
     }
   end
 
-  def test_cell_range
-    #To do
+  def test_cell_range_empty_if_no_cell
+    assert_equal(Axlsx.cell_range([]), "")
+  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_name_to_indices

data/test/tc_package.rb

@@ -7,6 +7,7 @@ class TestPackage < Test::Unit::TestCase
     ws = @package.workbook.add_worksheet
     ws.add_row ['Can', 'we', 'build it?']
     ws.add_row ['Yes!', 'We', 'can!']
+    ws.add_hyperlink :ref => ws.rows.first.cells.last, :location => 'https://github.com/randym'
     ws.workbook.add_defined_name("#{ws.name}!A1:C2", :name => '_xlnm.Print_Titles', :hidden => true)
     ws.protect_range('A1:C1')
     ws.protect_range(ws.rows.last.cells)

data/test/util/tc_validators.rb

@@ -158,4 +158,25 @@ 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
-end
+
+  def test_validate_family
+    assert_raise(ArgumentError) { Axlsx.validate_family 0 }
+    (1..5).each do |item|
+      assert_nothing_raised { Axlsx.validate_family item }
+    end
+  end
+
+  def test_validate_u
+    assert_raise(ArgumentError) { Axlsx.validate_cell_u :hoge }
+    [:none, :single, :double, :singleAccounting, :doubleAccounting].each do |sym|
+      assert_nothing_raised { Axlsx.validate_cell_u sym }
+    end
+  end
+
+  def test_range_validation
+     # exclusive
+     assert_raise(ArgumentError) { Axlsx::RangeValidator.validate('foo', 1, 10, 10, false) } 
+     # inclusive by default
+     assert_nothing_raised { Axlsx::RangeValidator.validate('foo', 1, 10, 10) }
+  end
+end

data/test/workbook/tc_defined_name.rb

@@ -10,14 +10,14 @@ class TestDefinedNames < Test::Unit::TestCase
   end
   
   def test_string_attributes
-    Axlsx::DefinedName::STRING_ATTRIBUTES.each do |attr|
+    %w(short_cut_key status_bar help description custom_menu comment).each do |attr|
       assert_raise(ArgumentError, 'only strings allowed in string attributes') { @dn.send("#{attr}=", 1) }
       assert_nothing_raised { @dn.send("#{attr}=", '_xlnm.Sheet_Title') }
     end
   end
 
   def test_boolean_attributes
-   Axlsx::DefinedName::BOOLEAN_ATTRIBUTES.each do |attr|
+   %w(workbook_parameter publish_to_server xlm vb_proceedure function hidden).each do |attr|
       assert_raise(ArgumentError, 'only booleanish allowed in string attributes') { @dn.send("#{attr}=", 'foo') }
       assert_nothing_raised { @dn.send("#{attr}=", 1) }
     end

data/test/workbook/tc_workbook.rb

@@ -16,6 +16,13 @@ class TestWorkbook < Test::Unit::TestCase
     assert_equal(@wb.use_autowidth, false)
   end
 
+
+  def test_sheet_by_name_retrieval
+    @wb.add_worksheet(:name=>'foo')
+    @wb.add_worksheet(:name=>'bar')
+    assert_equal('foo', @wb.sheet_by_name('foo').name)
+    
+  end
   def test_date1904
     assert_equal(Axlsx::Workbook.date1904, @wb.date1904)
     @wb.date1904 = :false
@@ -42,6 +49,14 @@ class TestWorkbook < Test::Unit::TestCase
     assert_equal(@wb.worksheets.first, ws, "the worksheet returned is the worksheet added")
     assert_equal(ws.name, "bob", "name option gets passed to worksheet")
   end
+  
+  def test_insert_worksheet
+    @wb.add_worksheet(:name => 'A')
+    @wb.add_worksheet(:name => 'B')
+    ws3 = @wb.insert_worksheet(0, :name => 'C')
+    assert_equal(ws3.name, @wb.worksheets.first.name)
+  end
+
   def test_relationships
     #current relationship size is 1 due to style relation
     assert(@wb.relationships.size == 1)

data/test/workbook/worksheet/auto_filter/tc_auto_filter.rb

@@ -0,0 +1,38 @@
+require 'tc_helper.rb'
+
+class TestAutoFilter < Test::Unit::TestCase
+
+  def setup
+    ws = Axlsx::Package.new.workbook.add_worksheet
+    3.times { |index| ws.add_row [1*index,2*index,3*index] }
+    @auto_filter = ws.auto_filter
+    @auto_filter.range = 'A1:C3'
+    @auto_filter.add_column 0, :filters, :filter_items => [1]
+  end
+
+  def test_defined_name
+    assert_equal("'Sheet1'!$A$1:$C$3", @auto_filter.defined_name)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@auto_filter.to_xml_string)
+    assert(doc.xpath("autoFilter[@ref='#{@auto_filter.range}']"))
+  end
+
+  def test_columns
+    assert @auto_filter.columns.is_a?(Axlsx::SimpleTypedList)
+    assert_equal @auto_filter.columns.allowed_types, [Axlsx::FilterColumn]
+  end
+
+  def test_add_column
+    @auto_filter.add_column(0, :filters) do |column|
+      assert column.is_a? FilterColumn
+    end
+  end
+
+  def test_applya
+    assert_equal nil, @auto_filter.worksheet.rows.last.hidden
+    @auto_filter.apply
+    assert_equal true, @auto_filter.worksheet.rows.last.hidden
+  end
+end

data/test/workbook/worksheet/auto_filter/tc_filter_column.rb

@@ -0,0 +1,76 @@
+require 'tc_helper.rb'
+
+class TestFilterColumn < Test::Unit::TestCase
+
+  def setup
+    @filter_column = Axlsx::FilterColumn.new(0, :filters, :filter_items => [200])
+  end
+
+
+  def test_initialize_col_id
+    assert_raise ArgumentError do
+      Axlsx::FilterColumn.new(0, :bobs_house_of_filter)
+    end 
+    assert_raise ArgumentError do 
+      Axlsx::FilterColumn.new(:penut, :filters)
+    end 
+  end
+
+  def test_initailize_filter_type
+    assert @filter_column.filter.is_a?(Axlsx::Filters)
+    assert_equal 1, @filter_column.filter.filter_items.size
+  end
+
+  def test_initialize_filter_type_filters_with_options
+    assert_equal 200, @filter_column.filter.filter_items.first.val
+  end
+
+  def test_initialize_with_block
+    filter_column = Axlsx::FilterColumn.new(0, :filters) do |filters|
+      filters.filter_items = [700, 100, 5]
+    end
+    assert_equal 3, filter_column.filter.filter_items.size
+    assert_equal 700, filter_column.filter.filter_items.first.val
+    assert_equal 5, filter_column.filter.filter_items.last.val
+  end
+
+  def test_default_show_button
+    assert_equal true, @filter_column.show_button
+  end
+
+  def test_default_hidden_button
+    assert_equal false, @filter_column.hidden_button
+  end
+
+  def test_show_button
+    assert_raise ArgumentError do
+      @filter_column.show_button = :foo 
+    end
+    assert_nothing_raised { @filter_column.show_button = false }
+  end
+
+  def test_hidden_button
+    assert_raise ArgumentError do
+      @filter_column.hidden_button = :hoge
+    end 
+    assert_nothing_raised { @filter_column.hidden_button = true }
+  end
+
+  def test_col_id=
+    assert_raise ArgumentError do 
+    @filter_column.col_id = :bar
+    end 
+  assert_nothing_raised { @filter_column.col_id = 7 }
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@filter_column.to_xml_string)
+    assert doc.xpath("//filterColumn[@colId=#{@filter_column.col_id}]")
+    assert doc.xpath("//filterColumn[@hiddenButton=#{@filter_column.hidden_button}]")
+    assert doc.xpath("//filterColumn[@showButton=#{@filter_column.show_button}]")
+
+
+
+    assert doc.xpath("//filterColumn/filters")
+  end
+end

data/test/workbook/worksheet/auto_filter/tc_filters.rb

@@ -0,0 +1,50 @@
+require 'tc_helper.rb'
+
+class TestFilters < Test::Unit::TestCase
+  def setup
+    @filters = Axlsx::Filters.new(:filter_items => [1, 'a'], 
+                                  :date_group_items =>[ { :date_time_grouping => :year, :year => 2011, :month => 11, :day => 11, :hour => 0, :minute => 0, :second => 0 } ] , 
+                                  :blank => true)
+  end
+
+  def test_blank
+    assert_equal true, @filters.blank
+    assert_raise(ArgumentError) { @filters.blank = :only_if_you_want_it }
+    @filters.blank = true
+    assert_equal true, @filters.blank
+  end
+
+  def test_calendar_type
+    assert_raise(ArgumentError) { @filters.calendar_type = 'monkey calendar' }
+    @filters.calendar_type = 'japan'
+    assert_equal('japan', @filters.calendar_type)
+  end
+
+  def test_filters_items
+    assert @filters.filter_items.is_a?(Array)
+    assert_equal 2, @filters.filter_items.size
+  end
+
+  def test_date_group_items
+    assert @filters.date_group_items.is_a?(Array)
+    assert_equal 1, @filters.date_group_items.size
+  end
+ 
+  def test_apply_is_false_for_matching_values
+    keeper = Object.new
+    def keeper.value; 'a'; end 
+    assert_equal false, @filters.apply(keeper)
+  end
+
+  def test_apply_is_true_for_non_matching_values
+    hidden = Object.new 
+    def hidden.value; 'b'; end
+    assert_equal true, @filters.apply(hidden)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@filters.to_xml_string)
+    assert_equal(1, doc.xpath('//filters[@blank="true"]').size)
+  end
+end
+

data/test/workbook/worksheet/tc_cell.rb

@@ -60,7 +60,7 @@ class TestCell < Test::Unit::TestCase
     assert_raise(ArgumentError, "type must be :string, :integer, :float, :date, :time, :boolean") { @c.type = :array }
     assert_nothing_raised("type can be changed") { @c.type = :string }
     assert_equal(@c.value, "1.0", "changing type casts the value")
-
+    assert_equal(:float, @row.add_cell(1.0/10**7).type, 'properly identify exponential floats as float type')
     assert_equal(@row.add_cell(Time.now).type, :time, 'time should be time')
     assert_equal(@row.add_cell(Date.today).type, :date, 'date should be date')
     assert_equal(@row.add_cell(true).type, :boolean, 'boolean should be boolean')
@@ -88,6 +88,7 @@ class TestCell < Test::Unit::TestCase
     assert_equal(@c.send(:cell_type_from_value, -1), :integer)
     assert_equal(@c.send(:cell_type_from_value, true), :boolean)
     assert_equal(@c.send(:cell_type_from_value, false), :boolean)
+    assert_equal(@c.send(:cell_type_from_value, 1.0/10**6), :float)
   end
 
   def test_cast_value
@@ -161,9 +162,12 @@ class TestCell < Test::Unit::TestCase
   end
 
   def test_u
+    @c.type = :string
     assert_raise(ArgumentError) { @c.u = -1.1 }
-    assert_nothing_raised { @c.u = false }
-    assert_equal(@c.u, false)
+    assert_nothing_raised { @c.u = :single }
+    assert_equal(@c.u, :single)
+    doc = Nokogiri::XML(@c.to_xml_string(1,1))
+    assert(doc.xpath('//u[@val="single"]'))
   end
 
   def test_i
@@ -186,8 +190,8 @@ class TestCell < Test::Unit::TestCase
 
   def test_family
     assert_raise(ArgumentError) { @c.family = -1.1 }
-    assert_nothing_raised { @c.family = "Who knows!" }
-    assert_equal(@c.family, "Who knows!")
+    assert_nothing_raised { @c.family = 5 }
+    assert_equal(@c.family, 5)
   end
 
   def test_b
@@ -250,6 +254,8 @@ class TestCell < Test::Unit::TestCase
   end
   
   def test_to_xml_string_with_run
+    # Actually quite a number of similar run styles
+    # but the processing should be the same
     @c.b = true
     @c.type = :string
     @c.value = "a"
@@ -258,6 +264,7 @@ class TestCell < Test::Unit::TestCase
     c_xml = Nokogiri::XML(@c.to_xml_string(1,1))
     assert(c_xml.xpath("//b"))
   end
+
   def test_to_xml_string_formula
     p = Axlsx::Package.new
     ws = p.workbook.add_worksheet do |sheet|
@@ -268,9 +275,32 @@ class TestCell < Test::Unit::TestCase
 
   end
 
+  def test_font_size_with_custom_style_and_no_sz
+    @c.style = @c.row.worksheet.workbook.styles.add_style :bg_color => 'FF00FF'
+    sz = @c.send(:font_size)
+    assert_equal(sz, @c.row.worksheet.workbook.styles.fonts.first.sz)
+  end
+
+  def test_font_size_with_bolding
+    @c.style = @c.row.worksheet.workbook.styles.add_style :b => true
+    assert_equal(@c.row.worksheet.workbook.styles.fonts.first.sz * 1.5, @c.send(:font_size))
+  end
+
+  def test_font_size_with_custom_sz
+    @c.style = @c.row.worksheet.workbook.styles.add_style :sz => 52
+    sz = @c.send(:font_size)
+    assert_equal(sz, 52)
+  end
+  
+
+  def test_cell_with_sz
+    @c.sz = 25
+    assert_equal(25, @c.send(:font_size))
+  end
   def test_to_xml
     # TODO This could use some much more stringent testing related to the xml content generated!
     @ws.add_row [Time.now, Date.today, true, 1, 1.0, "text", "=sum(A1:A2)"]
+    @ws.rows.last.cells[5].u = true
     schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
     doc = Nokogiri::XML(@ws.to_xml_string)
     errors = []