caxlsx 3.1.1 → 3.3.0

data/test/tc_package.rb

@@ -1,314 +0,0 @@
-# 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!']
-    @rt = Axlsx::RichText.new
-    @rt.add_run "run 1", :b => true, :i => false
-    ws.add_row [@rt]
-
-    ws.rows.last.add_cell('b', :type => :text)
-
-    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.workbook.add_view active_tab: 1, first_sheet: 0
-    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
-
-    ws.add_chart(Axlsx::BubbleChart, :title => 'bubble chart') do |chart|
-      chart.add_series :xData => [1,2,3,4], :yData => [1,3,2,4]
-      chart.d_lbls.show_val = true
-    end
-
-    @fname = 'axlsx_test_serialization.xlsx'
-    img = File.expand_path('../fixtures/image1.jpeg', __FILE__)
-    ws.add_image(:image_src => img, :noSelect => true, :noMove => true, :hyperlink=>"http://axlsx.blogspot.com") do |image|
-      image.width=720
-      image.height=666
-      image.hyperlink.tooltip = "Labeled Link"
-      image.start_at 5, 5
-      image.end_at 10, 10
-    end
-    ws.add_image :image_src => File.expand_path('../fixtures/image1.gif', __FILE__) do |image|
-      image.start_at 0, 20
-      image.width=360
-      image.height=333
-    end
-    ws.add_image :image_src => File.expand_path('../fixtures/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
-    @package.serialize(@fname)
-    assert_zip_file_matches_package(@fname, @package)
-    assert_created_with_rubyzip(@fname, @package)
-    File.delete(@fname)
-  end
-
-  def test_serialization_with_zip_command
-    @package.serialize(@fname, zip_command: "zip")
-    assert_zip_file_matches_package(@fname, @package)
-    assert_created_with_zip_command(@fname, @package)
-    File.delete(@fname)
-  end
-
-  def test_serialization_with_zip_command_and_absolute_path
-    fname = "#{Dir.tmpdir}/#{@fname}"
-    @package.serialize(fname, zip_command: "zip")
-    assert_zip_file_matches_package(fname, @package)
-    assert_created_with_zip_command(fname, @package)
-    File.delete(fname)
-  end
-
-  def test_serialization_with_invalid_zip_command
-    assert_raises Axlsx::ZipCommand::ZipError do
-      @package.serialize(@fname, zip_command: "invalid_zip")
-    end
-  end
-
-  def assert_zip_file_matches_package(fname, package)
-    zf = Zip::File.open(fname)
-    package.send(:parts).each{ |part| zf.get_entry(part[:entry]) }
-  end
-
-  def assert_created_with_rubyzip(fname, package)
-    assert_equal 2098, get_mtime(fname, package).year, "XLSX files created with RubyZip have 2098 as the file mtime"
-  end
-
-  def assert_created_with_zip_command(fname, package)
-    assert_equal Time.now.utc.year, get_mtime(fname, package).year, "XLSX files created with a zip command have the current year as the file mtime"
-  end
-
-  def get_mtime(fname, package)
-    zf = Zip::File.open(fname)
-    part = package.send(:parts).first
-    entry = zf.get_entry(part[:entry])
-    entry.mtime.utc
-  end
-
-  def test_serialization_with_deprecated_argument
-    warnings = capture_warnings do
-      @package.serialize(@fname, false)
-    end
-    assert_equal 1, warnings.size
-    assert_includes warnings.first, "confirm_valid as a boolean is deprecated"
-    File.delete(@fname)
-  end
-
-  def test_serialization_with_deprecated_three_arguments
-    warnings = capture_warnings do
-      @package.serialize(@fname, true, zip_command: "zip")
-    end
-    assert_zip_file_matches_package(@fname, @package)
-    assert_created_with_zip_command(@fname, @package)
-    assert_equal 2, warnings.size
-    assert_includes warnings.first, "with 3 arguments is deprecated"
-    File.delete(@fname)
-  end
-
-  def capture_warnings(&block)
-    original_warn = Kernel.instance_method(:warn)
-    warnings = []
-    Kernel.send(:define_method, :warn) { |string| warnings << string }
-    block.call
-    original_verbose = $VERBOSE
-    $VERBOSE = nil
-    Kernel.send(:define_method, :warn, original_warn)
-    $VERBOSE = original_verbose
-    warnings
-  end
-
-  # See comment for Package#zip_entry_for_part
-  def test_serialization_creates_identical_files_at_any_time_if_created_at_is_set
-    @package.core.created = Time.now
-    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_serialization_creates_files_with_excel_mime_type
-    assert_equal(Marcel::MimeType.for(@package.to_stream),
-                 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
-  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(25, p.size)
-
-  end
-
-  def test_shared_strings_requires_part
-    @package.use_shared_strings = true
-    @package.to_stream #ensure all cell_serializer paths are hit
-    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)
-    # Cached ids should be cleared
-    assert(Axlsx::Relationship.ids_cache.empty?)
-  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_mime_type_utils.rb

@@ -1,13 +0,0 @@
-require 'tc_helper.rb'
-class TestMimeTypeUtils < Test::Unit::TestCase
-  def setup
-    @test_img = File.dirname(__FILE__) + "/../fixtures/image1.jpeg"
-  end
-
-  def teardown
-  end
-
-  def test_mime_type_utils
-    assert_equal(Axlsx::MimeTypeUtils::get_mime_type(@test_img), 'image/jpeg')
-  end
-end

data/test/util/tc_serialized_attributes.rb

@@ -1,19 +0,0 @@
-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

@@ -1,77 +0,0 @@
-require 'tc_helper.rb'
-class TestSimpleTypedList < Test::Unit::TestCase
-  def setup
-    @list = Axlsx::SimpleTypedList.new Integer
-  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.to_ary, [1,2])
-  end
-end

data/test/util/tc_validators.rb

@@ -1,210 +0,0 @@
-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, :date, :time, :whole].each do |sym|
-      assert_nothing_raised { Axlsx.validate_data_validation_type sym }
-    end
-    assert_raise(ArgumentError) { Axlsx.validate_data_validation_error_style :other_symbol }
-    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 }
-
-    #display_blanks_as
-    [:gap, :span, :zero].each do |sym|
-      assert_nothing_raised { Axlsx.validate_display_blanks_as sym }
-    end
-    assert_raise(ArgumentError) { Axlsx.validate_display_blanks_as :other_symbol }
-    assert_raise(ArgumentError) { Axlsx.validate_display_blanks_as 'other_blank' }
-    assert_raise(ArgumentError) { Axlsx.validate_display_blanks_as 0 }
-
-    #view_visibility
-    [:visible, :hidden, :very_hidden].each do |sym|
-      assert_nothing_raised { Axlsx.validate_view_visibility sym }
-    end
-    assert_raise(ArgumentError) { Axlsx.validate_view_visibility :other_symbol }
-    assert_raise(ArgumentError) { Axlsx.validate_view_visibility 'other_visibility' }
-    assert_raise(ArgumentError) { Axlsx.validate_view_visibility 0 }
-
-    #marker_symbol
-    [:default, :circle, :dash, :diamond, :dot, :picture, :plus, :square, :star, :triangle, :x].each do |sym|
-      assert_nothing_raised { Axlsx.validate_marker_symbol sym }
-    end
-    assert_raise(ArgumentError) { Axlsx.validate_marker_symbol :other_symbol }
-    assert_raise(ArgumentError) { Axlsx.validate_marker_symbol 'other_marker' }
-    assert_raise(ArgumentError) { Axlsx.validate_marker_symbol 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

data/test/workbook/tc_defined_name.rb

@@ -1,49 +0,0 @@
-require 'tc_helper'
-
-class TestDefinedNames < Test::Unit::TestCase
-  def setup
-    @dn = Axlsx::DefinedName.new('Sheet1!A1:A1')
-  end
-
-  def test_initialize
-    assert_equal('Sheet1!A1:A1', @dn.formula)
-  end
-
-  def test_string_attributes
-    %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
-   %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
-
-  end
-
-  def test_local_sheet_id
-    assert_raise(ArgumentError, 'local_sheet_id must be an unsigned int') { @dn.local_sheet_id = -1 }
-    assert_nothing_raised { @dn.local_sheet_id = 1 }
-  end
-
-  def test_do_not_camelcase_value_for_name
-    @dn.name = '_xlnm._FilterDatabase'
-    doc = Nokogiri::XML(@dn.to_xml_string)
-    assert_equal(doc.xpath("//definedName[@name='_xlnm._FilterDatabase']").size, 1)
-    assert_equal('Sheet1!A1:A1', doc.xpath('//definedName').text)
-  end
-
-  def test_to_xml_string
-    assert_raise(ArgumentError, 'name is required for serialization') { @dn.to_xml_string }
-    @dn.name = '_xlnm.Print_Titles'
-    @dn.hidden = true
-    doc = Nokogiri::XML(@dn.to_xml_string)
-    assert_equal(doc.xpath("//definedName[@name='_xlnm.Print_Titles']").size, 1)
-    assert_equal(doc.xpath("//definedName[@hidden='1']").size, 1)
-    assert_equal('Sheet1!A1:A1', doc.xpath('//definedName').text)
-  end
-
-end