caxlsx 2.0.2

data/test/tc_axlsx.rb

@@ -0,0 +1,72 @@
+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
+    Axlsx.trust_input = true
+    assert_equal true, Axlsx.trust_input
+  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
+    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
+
+end

data/test/tc_helper.rb

@@ -0,0 +1,10 @@
+$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"

data/test/tc_package.rb

@@ -0,0 +1,227 @@
+# encoding: UTF-8
+require 'tc_helper.rb'
+
+class TestPackage < Test::Unit::TestCase
+  def setup
+    @package = Axlsx::Package.new
+    ws = @package.workbook.add_worksheet
+    ws.add_row ['Can', 'we', 'build it?']
+    ws.add_row ['Yes!', 'We', 'can!']
+    ws.outline_level_rows 0, 1
+    ws.outline_level_columns 0, 1
+    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)
+    ws.add_comment :author => 'alice', :text => 'Hi Bob', :ref => 'A12'
+    ws.add_comment :author => 'bob', :text => 'Hi Alice', :ref => 'F19'
+    ws.sheet_view do |vs|
+      vs.pane do |p|
+        p.active_pane = :top_right
+        p.state = :split
+        p.x_split = 11080
+        p.y_split = 5000
+        p.top_left_cell = 'C44'
+      end
+
+      vs.add_selection(:top_left, { :active_cell => 'A2', :sqref => 'A2' })
+      vs.add_selection(:top_right, { :active_cell => 'I10', :sqref => 'I10' })
+      vs.add_selection(:bottom_left, { :active_cell => 'E55', :sqref => 'E55' })
+      vs.add_selection(:bottom_right, { :active_cell => 'I57', :sqref => 'I57' })
+    end
+
+    ws.add_chart(Axlsx::Pie3DChart, :title => "これは？", :start_at => [0,3]) do |chart|
+      chart.add_series :data=>[1,2,3], :labels=>["a", "b", "c"]
+      chart.d_lbls.show_val = true
+      chart.d_lbls.d_lbl_pos = :outEnd
+      chart.d_lbls.show_percent = true
+    end
+
+    ws.add_chart(Axlsx::Line3DChart, :title => "axis labels") do |chart|
+      chart.valAxis.title = 'bob'
+      chart.d_lbls.show_val = true
+    end
+
+    ws.add_chart(Axlsx::Bar3DChart, :title => 'bar chart') do |chart|
+      chart.add_series :data => [1,4,5], :labels => %w(A B C)
+      chart.d_lbls.show_percent = true
+    end
+
+    ws.add_chart(Axlsx::ScatterChart, :title => 'scat man') do |chart|
+      chart.add_series :xData => [1,2,3,4], :yData => [4,3,2,1]
+      chart.d_lbls.show_val = true
+    end
+
+    @fname = 'axlsx_test_serialization.xlsx'
+    img = File.expand_path('../../examples/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
+      image.hyperlink.tooltip = "Labeled Link"
+      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|
+      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|
+      image.start_at 9, 20
+      image.width = 180
+      image.height = 167
+    end
+    ws.add_table 'A1:C1'
+
+    ws.add_pivot_table 'G5:G6', 'A1:B3'
+
+    ws.add_page_break "B2"
+
+  end
+
+  def test_use_autowidth
+    @package.use_autowidth = false
+    assert(@package.workbook.use_autowidth == false)
+  end
+
+  def test_core_accessor
+    assert_equal(@package.core, @package.instance_values["core"])
+    assert_raise(NoMethodError) {@package.core = nil }
+  end
+
+  def test_app_accessor
+    assert_equal(@package.app, @package.instance_values["app"])
+    assert_raise(NoMethodError) {@package.app = nil }
+  end
+
+  def test_use_shared_strings
+    assert_equal(@package.use_shared_strings, nil)
+    assert_raise(ArgumentError) {@package.use_shared_strings 9}
+    assert_nothing_raised {@package.use_shared_strings = true}
+    assert_equal(@package.use_shared_strings, @package.workbook.use_shared_strings)
+  end
+
+  def test_default_objects_are_created
+    assert(@package.instance_values["app"].is_a?(Axlsx::App), 'App object not created')
+    assert(@package.instance_values["core"].is_a?(Axlsx::Core), 'Core object not created')
+    assert(@package.workbook.is_a?(Axlsx::Workbook), 'Workbook object not created')
+    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
+        @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
+    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)
+    Axlsx::Workbook.send(:class_variable_set, :@@date1904, 9900)
+    assert(@package.validate.size > 0)
+  end
+
+  def test_parts
+    p = @package.send(:parts)
+    #all parts have an entry
+    assert_equal(p.select{ |part| part[:entry] =~ /_rels\/\.rels/ }.size, 1, "rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /docProps\/core\.xml/ }.size, 1, "core missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /docProps\/app\.xml/ }.size, 1, "app missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/_rels\/workbook\.xml\.rels/ }.size, 1, "workbook rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/workbook\.xml/ }.size, 1, "workbook missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /\[Content_Types\]\.xml/ }.size, 1, "content types missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/styles\.xml/ }.size, 1, "styles missin")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/drawings\/_rels\/drawing\d\.xml\.rels/ }.size, @package.workbook.drawings.size, "one or more drawing rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/drawings\/drawing\d\.xml/ }.size, @package.workbook.drawings.size, "one or more drawings missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/charts\/chart\d\.xml/ }.size, @package.workbook.charts.size, "one or more charts missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/worksheets\/sheet\d\.xml/ }.size, @package.workbook.worksheets.size, "one or more sheet missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/worksheets\/_rels\/sheet\d\.xml\.rels/ }.size, @package.workbook.worksheets.size, "one or more sheet rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/comments\d\.xml/ }.size, @package.workbook.worksheets.size, "one or more sheet rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/pivotTables\/pivotTable\d\.xml/ }.size, @package.workbook.worksheets.first.pivot_tables.size, "one or more pivot tables missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/pivotTables\/_rels\/pivotTable\d\.xml.rels/ }.size, @package.workbook.worksheets.first.pivot_tables.size, "one or more pivot tables rels missing")
+    assert_equal(p.select{ |part| part[:entry] =~ /xl\/pivotCache\/pivotCacheDefinition\d\.xml/ }.size, @package.workbook.worksheets.first.pivot_tables.size, "one or more pivot tables missing")
+
+
+    #no mystery parts
+    assert_equal(24, p.size)
+
+  end
+
+  def test_shared_strings_requires_part
+    @package.use_shared_strings = true
+    p = @package.send(:parts)
+    assert_equal(p.select{ |part| part[:entry] =~/xl\/sharedStrings.xml/}.size, 1, "shared strings table missing")
+  end
+
+  def test_workbook_is_a_workbook
+    assert @package.workbook.is_a? Axlsx::Workbook
+  end
+
+  def test_base_content_types
+    ct = @package.send(:base_content_types)
+    assert(ct.select { |c| c.ContentType == Axlsx::RELS_CT }.size == 1, "rels content type missing")
+    assert(ct.select { |c| c.ContentType == Axlsx::XML_CT }.size == 1, "xml content type missing")
+    assert(ct.select { |c| c.ContentType == Axlsx::APP_CT }.size == 1, "app content type missing")
+    assert(ct.select { |c| c.ContentType == Axlsx::CORE_CT }.size == 1, "core content type missing")
+    assert(ct.select { |c| c.ContentType == Axlsx::STYLES_CT }.size == 1, "styles content type missing")
+    assert(ct.select { |c| c.ContentType == Axlsx::WORKBOOK_CT }.size == 1, "workbook content type missing")
+    assert(ct.size == 6)
+  end
+
+  def test_content_type_added_with_shared_strings
+    @package.use_shared_strings = true
+    ct = @package.send(:content_types)
+    assert(ct.select { |type| type.ContentType == Axlsx::SHARED_STRINGS_CT }.size == 1)
+  end
+
+  def test_name_to_indices
+    assert(Axlsx::name_to_indices('A1') == [0,0])
+    assert(Axlsx::name_to_indices('A100') == [0,99], 'needs to axcept rows that contain 0')
+  end
+
+  def test_to_stream
+    stream = @package.to_stream
+    assert(stream.is_a?(StringIO))
+    # this is just a roundabout guess for a package as it is build now
+    # in testing.
+    assert(stream.size > 80000)
+  end
+
+  def test_encrypt
+    # this is no where near close to ready yet
+    assert(@package.encrypt('your_mom.xlsxl', 'has a password') == false)
+  end
+end

data/test/util/tc_serialized_attributes.rb

@@ -0,0 +1,19 @@
+require 'tc_helper.rb'
+class Funk
+  include Axlsx::Accessors
+  include Axlsx::SerializedAttributes
+  serializable_attributes :camel_symbol, :boolean, :integer
+
+  attr_accessor :camel_symbol, :boolean, :integer
+end
+
+class TestSeralizedAttributes < Test::Unit::TestCase
+  def setup
+    @object = Funk.new
+  end
+
+  def test_camel_symbol
+    @object.camel_symbol = :foo_bar
+    assert_equal('camelSymbol="fooBar" ', @object.serialized_attributes)
+  end
+end

data/test/util/tc_simple_typed_list.rb

@@ -0,0 +1,78 @@
+require 'tc_helper.rb'
+class TestSimpleTypedList < Test::Unit::TestCase
+  def setup
+    @list = Axlsx::SimpleTypedList.new Fixnum
+  end
+
+  def teardown
+  end
+
+  def test_type_is_a_class_or_array_of_class
+    assert_nothing_raised { Axlsx::SimpleTypedList.new Integer }
+    assert_nothing_raised { Axlsx::SimpleTypedList.new [Integer,String] }
+    assert_raise(ArgumentError) { Axlsx::SimpleTypedList.new }
+    assert_raise(ArgumentError) { Axlsx::SimpleTypedList.new "1" }
+    assert_raise(ArgumentError) { Axlsx::SimpleTypedList.new [Integer, "Class"] }
+  end
+
+  def test_indexed_based_assignment
+    #should not allow nil assignment
+    assert_raise(ArgumentError) { @list[0] = nil }
+    assert_raise(ArgumentError) { @list[0] = "1" }
+    assert_nothing_raised { @list[0] = 1 }
+  end
+
+  def test_concat_assignment
+    assert_raise(ArgumentError) { @list << nil }
+    assert_raise(ArgumentError) { @list << "1" }
+    assert_nothing_raised { @list << 1 }
+  end
+
+  def test_concat_should_return_index
+    assert( @list.size == 0 )
+    assert( @list << 1 == 0 )
+    assert( @list << 2 == 1 )
+    @list.delete_at 0
+    assert( @list << 3 == 1 )
+    assert( @list.index(2) == 0 )
+  end
+
+  def test_push_should_return_index
+    assert( @list.push(1) == 0 )
+    assert( @list.push(2) == 1 )
+    @list.delete_at 0
+    assert( @list.push(3) == 1 )
+    assert( @list.index(2) == 0 )
+  end
+
+  def test_locking
+    @list.push 1
+    @list.push 2
+    @list.push 3
+    @list.lock
+
+    assert_raise(ArgumentError) { @list.delete 1  }
+    assert_raise(ArgumentError) { @list.delete_at 1 }
+    assert_raise(ArgumentError) { @list.delete_at 2 }
+    @list.push 4
+    assert_nothing_raised { @list.delete_at 3 }
+    @list.unlock
+    #ignore garbage
+    assert_nothing_raised { @list.delete 0 }
+    assert_nothing_raised { @list.delete 9 }
+  end
+  
+  def test_delete
+    @list.push 1
+    assert(@list.size == 1)
+    @list.delete 1
+    assert(@list.empty?)
+  end
+
+  def test_equality
+    @list.push 1
+    @list.push 2
+    assert_equal(@list, [1,2])
+    
+  end
+end

data/test/util/tc_validators.rb

@@ -0,0 +1,186 @@
+require 'tc_helper.rb'
+class TestValidators < Test::Unit::TestCase
+  def setup
+  end
+  def teardown
+  end
+
+  def test_validators
+    #unsigned_int
+    assert_nothing_raised { Axlsx.validate_unsigned_int 1 }
+    assert_nothing_raised { Axlsx.validate_unsigned_int(+1) }
+    assert_raise(ArgumentError) { Axlsx.validate_unsigned_int(-1)}
+    assert_raise(ArgumentError) { Axlsx.validate_unsigned_int('1') }
+
+    #int
+    assert_nothing_raised { Axlsx.validate_int(1) }
+    assert_nothing_raised { Axlsx.validate_int(-1) }
+    assert_raise(ArgumentError) { Axlsx.validate_int('a')}
+    assert_raise(ArgumentError) { Axlsx.validate_int(Array) }
+
+    #boolean (as 0 or 1, :true, :false, true, false, or "true," "false")
+    [0,1,:true, :false, true, false, "true", "false"].each do |v|
+      assert_nothing_raised { Axlsx.validate_boolean 0 }
+    end
+    assert_raise(ArgumentError) { Axlsx.validate_boolean 2 }
+
+    #string
+    assert_nothing_raised { Axlsx.validate_string "1" }
+    assert_raise(ArgumentError) { Axlsx.validate_string 2 }
+    assert_raise(ArgumentError) { Axlsx.validate_string false }
+
+    #float
+    assert_nothing_raised { Axlsx.validate_float 1.0 }
+    assert_raise(ArgumentError) { Axlsx.validate_float 2 }
+    assert_raise(ArgumentError) { Axlsx.validate_float false }
+
+    #pattern_type
+    assert_nothing_raised { Axlsx.validate_pattern_type :none }
+    assert_raise(ArgumentError) { Axlsx.validate_pattern_type "none" }
+    assert_raise(ArgumentError) { Axlsx.validate_pattern_type "crazy_pattern" }
+    assert_raise(ArgumentError) { Axlsx.validate_pattern_type false }
+
+    #gradient_type
+    assert_nothing_raised { Axlsx.validate_gradient_type :path }
+    assert_raise(ArgumentError) { Axlsx.validate_gradient_type nil }
+    assert_raise(ArgumentError) { Axlsx.validate_gradient_type "fractal" }
+    assert_raise(ArgumentError) { Axlsx.validate_gradient_type false }
+
+    #horizontal alignment
+    assert_nothing_raised { Axlsx.validate_horizontal_alignment :general }
+    assert_raise(ArgumentError) { Axlsx.validate_horizontal_alignment nil }
+    assert_raise(ArgumentError) { Axlsx.validate_horizontal_alignment "wavy" }
+    assert_raise(ArgumentError) { Axlsx.validate_horizontal_alignment false }
+
+    #vertical alignment
+    assert_nothing_raised { Axlsx.validate_vertical_alignment :top }
+    assert_raise(ArgumentError) { Axlsx.validate_vertical_alignment nil }
+    assert_raise(ArgumentError) { Axlsx.validate_vertical_alignment "dynamic" }
+    assert_raise(ArgumentError) { Axlsx.validate_vertical_alignment false }
+
+    #contentType
+    assert_nothing_raised { Axlsx.validate_content_type Axlsx::WORKBOOK_CT }
+    assert_raise(ArgumentError) { Axlsx.validate_content_type nil }
+    assert_raise(ArgumentError) { Axlsx.validate_content_type "http://some.url" }
+    assert_raise(ArgumentError) { Axlsx.validate_content_type false }
+
+    #relationshipType
+    assert_nothing_raised { Axlsx.validate_relationship_type Axlsx::WORKBOOK_R }
+    assert_raise(ArgumentError) { Axlsx.validate_relationship_type nil }
+    assert_raise(ArgumentError) { Axlsx.validate_relationship_type "http://some.url" }
+    assert_raise(ArgumentError) { Axlsx.validate_relationship_type false }
+
+    #number_with_unit
+    assert_nothing_raised { Axlsx.validate_number_with_unit "210mm" }
+    assert_nothing_raised { Axlsx.validate_number_with_unit "8.5in" }
+    assert_nothing_raised { Axlsx.validate_number_with_unit "29.7cm" }
+    assert_nothing_raised { Axlsx.validate_number_with_unit "120pt" }
+    assert_nothing_raised { Axlsx.validate_number_with_unit "0pc" }
+    assert_nothing_raised { Axlsx.validate_number_with_unit "12.34pi" }
+    assert_raise(ArgumentError) { Axlsx.validate_number_with_unit nil }
+    assert_raise(ArgumentError) { Axlsx.validate_number_with_unit "210" }
+    assert_raise(ArgumentError) { Axlsx.validate_number_with_unit 210 }
+    assert_raise(ArgumentError) { Axlsx.validate_number_with_unit "mm" }
+    assert_raise(ArgumentError) { Axlsx.validate_number_with_unit "-29cm" }
+
+    #scale_10_400
+    assert_nothing_raised { Axlsx.validate_scale_10_400 10 }
+    assert_nothing_raised { Axlsx.validate_scale_10_400 100 }
+    assert_nothing_raised { Axlsx.validate_scale_10_400 400 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_10_400 9 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_10_400 10.0 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_10_400 400.1 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_10_400 "99" }
+    
+    #scale_0_10_400
+    assert_nothing_raised { Axlsx.validate_scale_0_10_400 0 }
+    assert_nothing_raised { Axlsx.validate_scale_0_10_400 10 }
+    assert_nothing_raised { Axlsx.validate_scale_0_10_400 100 }
+    assert_nothing_raised { Axlsx.validate_scale_0_10_400 400 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_0_10_400 9 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_0_10_400 10.0 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_0_10_400 400.1 }
+    assert_raise(ArgumentError) { Axlsx.validate_scale_0_10_400 "99" }
+    
+    #page_orientation
+    assert_nothing_raised { Axlsx.validate_page_orientation :default }
+    assert_nothing_raised { Axlsx.validate_page_orientation :landscape }
+    assert_nothing_raised { Axlsx.validate_page_orientation :portrait }
+    assert_raise(ArgumentError) { Axlsx.validate_page_orientation nil }
+    assert_raise(ArgumentError) { Axlsx.validate_page_orientation 1 }
+    assert_raise(ArgumentError) { Axlsx.validate_page_orientation "landscape" }
+    
+    #data_validation_error_style
+    [:information, :stop, :warning].each do |sym|
+      assert_nothing_raised { Axlsx.validate_data_validation_error_style sym }
+    end
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style :other_symbol }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 'warning' }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 0 }
+    
+    #data_validation_operator
+    [:lessThan, :lessThanOrEqual, :equal, :notEqual, :greaterThanOrEqual, :greaterThan, :between, :notBetween].each do |sym|
+      assert_nothing_raised { Axlsx.validate_data_validation_operator sym }
+    end
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style :other_symbol }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 'lessThan' }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 0 }
+    
+    #data_validation_type
+    [:custom, :data, :decimal, :list, :none, :textLength, :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 }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 'decimal' }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 0 }
+    
+    #sheet_view_type
+    [:normal, :page_break_preview, :page_layout].each do |sym|
+      assert_nothing_raised { Axlsx.validate_sheet_view_type sym }
+    end
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style :other_symbol }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 'page_layout' }
+    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style 0 }
+    
+    #active_pane_type
+    [:bottom_left, :bottom_right, :top_left, :top_right].each do |sym|
+      assert_nothing_raised { Axlsx.validate_pane_type sym }
+    end
+    assert_raise(ArgumentError) { Axlsx.validate_pane_type :other_symbol }
+    assert_raise(ArgumentError) { Axlsx.validate_pane_type 'bottom_left' }
+    assert_raise(ArgumentError) { Axlsx.validate_pane_type 0 }
+    
+    #split_state_type
+    [:frozen, :frozen_split, :split].each do |sym|
+      assert_nothing_raised { Axlsx.validate_split_state_type sym }
+    end
+    assert_raise(ArgumentError) { Axlsx.validate_split_state_type :other_symbol }
+    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|
+      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