ricardoo27-writeexcel 0.6.12.1

data/test/test_formula.rb

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+require 'helper'
+
+class TC_Formula < Test::Unit::TestCase
+
+  def setup
+    @formula = Writeexcel::Formula.new(0)
+  end
+
+  def test_scan
+    # scan must return array of token info
+    string01 = '1 + 2 * LEN("String")'
+    expected01 = [
+      [:NUMBER, '1'],
+      ['+',     '+'],
+      [:NUMBER, '2'],
+      ['*',     '*'],
+      [:FUNC,   'LEN'],
+      ['(',     '('],
+      [:STRING, '"String"'],
+      [')',     ')'],
+      [:EOL,    nil]
+    ]
+    assert_kind_of(Array, @formula.scan(string01))
+    assert_equal(expected01, @formula.scan(string01))
+
+    string02 = 'IF(A1>=0,SIN(0),COS(90))'
+    expected02 = [
+      [:FUNC,   'IF'],
+      ['(',     '('],
+      [:REF2D,  'A1'],
+      [:GE,     '>='],
+      [:NUMBER, '0'],
+      [',',     ','],
+      [:FUNC,   'SIN'],
+      ['(',     '('],
+      [:NUMBER, '0'],
+      [')',     ')'],
+      [',',     ','],
+      [:FUNC,   'COS'],
+      ['(',     '('],
+      [:NUMBER, '90'],
+      [')',     ')'],
+      [')',     ')'],
+      [:EOL,    nil]
+    ]
+    assert_kind_of(Array, @formula.scan(string02))
+    assert_equal(expected02, @formula.scan(string02))
+  end
+
+  def test_reverse
+    testcase = [
+      [ [0,1,2,3,4], [0,[1,[2,3,[4]]]]      ],
+      [ [0,1,2,3,4,5], [[0,1,[2,3]],[4,5]]  ]
+    ]
+    testcase.each do |t|
+      assert_equal(t[0], @formula.reverse(t[1]))
+    end
+  end
+
+end

data/test/test_ole.rb

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+require 'helper'
+require 'stringio'
+
+class TC_OLE < Test::Unit::TestCase
+
+  def setup
+    @file  = StringIO.new
+    @ole  = OLEWriter.new(@file)
+  end
+
+  def test_constructor
+    assert_kind_of(OLEWriter, @ole)
+  end
+
+  def test_constants
+    assert_equal(7087104, OLEWriter::MaxSize)
+    assert_equal(4096, OLEWriter::BlockSize)
+    assert_equal(512, OLEWriter::BlockDiv)
+    assert_equal(127, OLEWriter::ListBlocks)
+  end
+
+  def test_calculate_sizes
+    assert_respond_to(@ole, :calculate_sizes)
+    assert_nothing_raised{ @ole.calculate_sizes }
+    assert_equal(0, @ole.big_blocks)
+    assert_equal(1, @ole.list_blocks)
+    assert_equal(0, @ole.root_start)
+  end
+
+  def test_set_size_too_big
+    assert(!@ole.set_size(999999999))
+  end
+
+  def test_book_size_large
+    assert_nothing_raised{ @ole.set_size(8192) }
+    assert_equal(8192, @ole.book_size)
+  end
+
+  def test_book_size_small
+    assert_nothing_raised{ @ole.set_size(2048) }
+    assert_equal(4096, @ole.book_size)
+  end
+
+  def test_biff_size
+    assert_nothing_raised{ @ole.set_size(2048) }
+    assert_equal(2048, @ole.biff_size)
+  end
+
+  def test_size_allowed
+    assert_nothing_raised{ @ole.set_size }
+    assert_equal(true, @ole.size_allowed)
+  end
+
+  def test_big_block_size_default
+    assert_nothing_raised{ @ole.set_size }
+    assert_nothing_raised{ @ole.calculate_sizes }
+    assert_equal(8, @ole.big_blocks, "Bad big block size")
+  end
+
+  def test_big_block_size_rounded_up
+    assert_nothing_raised{ @ole.set_size(4099) }
+    assert_nothing_raised{ @ole.calculate_sizes }
+    assert_equal(9, @ole.big_blocks, "Bad big block size")
+  end
+
+  def test_list_block_size
+    assert_nothing_raised{ @ole.set_size }
+    assert_nothing_raised{ @ole.calculate_sizes }
+    assert_equal(1, @ole.list_blocks, "Bad list block size")
+  end
+
+  def test_root_start_size_default
+    assert_nothing_raised{ @ole.set_size }
+    assert_nothing_raised{ @ole.calculate_sizes }
+    assert_equal(8, @ole.big_blocks, "Bad root start size")
+  end
+
+  def test_root_start_size_rounded_up
+    assert_nothing_raised{ @ole.set_size(4099) }
+    assert_nothing_raised{ @ole.calculate_sizes }
+    assert_equal(9, @ole.big_blocks, "Bad root start size")
+  end
+
+  def test_write_header
+    assert_nothing_raised{ @ole.write_header }
+    #assert_nothing_raised{ @ole.close }
+    #assert_equal(512, File.size(@file))
+  end
+
+  def test_write_big_block_depot
+    assert_nothing_raised{ @ole.write_big_block_depot }
+    #assert_nothing_raised{ @ole.close }
+    #assert_equal(8, File.size(@file))
+  end
+
+  def test_write_property_storage_size
+    assert_nothing_raised{ @ole.write_property_storage }
+    #assert_nothing_raised{ @ole.close }
+    #assert_equal(512, File.size(@file))
+  end
+end

data/test/test_storage_lite.rb

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+require 'helper'
+require 'stringio'
+
+class TC_OLEStorageLite < Test::Unit::TestCase
+  TEST_DIR    = File.expand_path(File.dirname(__FILE__))
+  PERL_OUTDIR = File.join(TEST_DIR, 'perl_output')
+  EXCEL_OUTDIR = File.join(TEST_DIR, 'excelfile')
+
+  def setup
+    @ole = OLEStorageLite.new
+  end
+
+  def test_olestoragelite_new
+    ole = OLEStorageLite.new
+    assert_nil(ole.file)
+
+    io = StringIO.new
+    ole = OLEStorageLite.new(io)
+    assert_equal(io, ole.file)
+
+    file = 'test.ole'
+    ole = OLEStorageLite.new(file)
+    assert_equal(file, ole.file)
+
+  end
+
+  def test_asc2ucs
+    result = @ole.asc2ucs('Root Entry')
+    target = %w(
+        52 00 6F 00 6F 00 74 00 20 00 45 00 6E 00 74 00 72 00 79 00
+      ).join(" ")
+    assert_equal(target, unpack_record(result))
+  end
+
+  def test_ucs2asc
+    strings = [
+        'Root Entry',
+        ''
+      ]
+    strings.each do |str|
+      result = @ole.ucs2asc(@ole.asc2ucs(str))
+      assert_equal(str, result)
+    end
+  end
+
+  def unpack_record(data)
+    data.unpack('C*').map! {|c| sprintf("%02X", c) }.join(' ')
+  end
+
+end
+
+class TC_OLEStorageLitePPSFile < Test::Unit::TestCase
+  def test_constructor
+    data = [
+        { :name => 'name', :data => 'data' },
+        { :name => '',     :data => 'data' },
+        { :name => 'name', :data => ''     },
+        { :name => '',     :data => ''     },
+      ]
+    data.each do |d|
+      olefile = OLEStorageLitePPSFile.new(d[:name])
+      assert_equal(d[:name], olefile.name)
+    end
+    data.each do |d|
+      olefile = OLEStorageLitePPSFile.new(d[:name], d[:data])
+      assert_equal(d[:name], olefile.name)
+      assert_equal(d[:data], olefile.data)
+    end
+  end
+
+  def test_append_no_file
+    olefile = OLEStorageLitePPSFile.new('name')
+    assert_equal('', olefile.data)
+
+    data = [ "data", "\r\n", "\r", "\n" ]
+    data.each do |d|
+      olefile = OLEStorageLitePPSFile.new('name')
+      olefile.append(d)
+      assert_equal(d, olefile.data)
+    end
+  end
+
+  def test_append_tempfile
+    data = [ "data", "\r\n", "\r", "\n" ]
+    data.each do |d|
+      olefile = OLEStorageLitePPSFile.new('name')
+      olefile.set_file
+      pps_file = olefile.pps_file
+
+      olefile.append(d)
+      pps_file.open
+      pps_file.binmode
+      assert_equal(d, pps_file.read)
+    end
+  end
+
+  def test_append_stringio
+    data = [ "data", "\r\n", "\r", "\n" ]
+    data.each do |d|
+      sio = StringIO.new
+      olefile = OLEStorageLitePPSFile.new('name')
+      olefile.set_file(sio)
+      pps_file = olefile.pps_file
+
+      olefile.append(d)
+      pps_file.rewind
+      assert_equal(d, pps_file.read)
+    end
+  end
+
+  def unpack_record(data)
+    data.unpack('C*').map! {|c| sprintf("%02X", c) }.join(' ')
+  end
+
+end

data/test/test_workbook.rb

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+require 'helper'
+require "stringio"
+
+class TC_Workbook < Test::Unit::TestCase
+
+  def setup
+    @test_file  = StringIO.new
+    @workbook   = Workbook.new(@test_file)
+  end
+
+  def test_new
+    assert_kind_of(Workbook, @workbook)
+  end
+
+  def test_add_worksheet
+    sheetnames = ['sheet1', 'sheet2']
+    (0 .. sheetnames.size-1).each do |i|
+      sheets = @workbook.sheets
+      assert_equal(i, sheets.size)
+      @workbook.add_worksheet(sheetnames[i])
+      sheets = @workbook.sheets
+      assert_equal(i+1, sheets.size)
+    end
+  end
+
+  def test_set_tempdir_after_sheet_added
+    # after shees added, call set_tempdir raise RuntimeError
+    @workbook.add_worksheet('name')
+    assert_raise(RuntimeError, "already sheet exists, but set_tempdir() doesn't raise"){
+      @workbook.set_tempdir
+    }
+  end
+
+  def test_set_tempdir_with_invalid_dir
+    # invalid dir raise RuntimeError
+    while true do
+      dir = Time.now.to_s
+      break unless FileTest.directory?(dir)
+      sleep 0.1
+    end
+    assert_raise(RuntimeError, "set_tempdir() doesn't raise invalid dir:#{dir}."){
+      @workbook.set_tempdir(dir)
+    }
+  end
+
+  def test_check_sheetname
+    worksheet1 = @workbook.add_worksheet              # implicit name 'Sheet1'
+    worksheet2 = @workbook.add_worksheet              # implicit name 'Sheet2'
+    worksheet3 = @workbook.add_worksheet 'Sheet3'     # explicit name 'Sheet3'
+    worksheet4 = @workbook.add_worksheet 'Sheetz'     # explicit name 'Sheetz'
+
+    valid_sheetnames.each do |test|
+      target    = test[0]
+      sheetname = test[1]
+      caption   = test[2]
+      assert_nothing_raised { @workbook.add_worksheet(sheetname) }
+    end
+
+    invalid_sheetnames.each do |test|
+      target    = test[0]
+      sheetname = test[1]
+      caption   = test[2]
+      assert_raise(RuntimeError, "sheetname: #{sheetname}") {
+          @workbook.add_worksheet(sheetname)
+        }
+    end
+  end
+
+  def test_check_sheetname_raise_if_same_utf16be_sheet_name
+    smily = [0x263a].pack('n')
+    @workbook.add_worksheet(smily, true)
+    assert_raise(RuntimeError) { @workbook.add_worksheet(smily, true)}
+  end
+
+  def test_check_sheetname_utf8_only
+    ['Лист 1', 'Лист 2', 'Лист 3'].each do |sheetname|
+      assert_nothing_raised { @workbook.add_worksheet(sheetname) }
+    end
+  end
+
+  def test_check_unicode_bytes_even
+    assert_nothing_raised(RuntimeError){ @workbook.add_worksheet('ab', 1)}
+    assert_raise(RuntimeError){ @workbook.add_worksheet('abc', 1)}
+  end
+
+  def test_raise_set_compatibility_after_sheet_creation
+    @workbook.add_worksheet
+    assert_raise(RuntimeError) { @workbook.compatibility_mode }
+  end
+
+  def valid_sheetnames
+    [
+      # Tests for valid names
+      [ 'PASS', nil,        'No worksheet name'           ],
+      [ 'PASS', '',         'Blank worksheet name'        ],
+      [ 'PASS', 'Sheet10',  'Valid worksheet name'        ],
+      [ 'PASS', 'a' * 31,   'Valid 31 char name'          ]
+    ]
+  end
+
+  def invalid_sheetnames
+    [
+      # Tests for invalid names
+      [ 'FAIL', 'Sheet1',   'Caught duplicate name'       ],
+      [ 'FAIL', 'Sheet2',   'Caught duplicate name'       ],
+      [ 'FAIL', 'Sheet3',   'Caught duplicate name'       ],
+      [ 'FAIL', 'sheet1',   'Caught case-insensitive name'],
+      [ 'FAIL', 'SHEET1',   'Caught case-insensitive name'],
+      [ 'FAIL', 'sheetz',   'Caught case-insensitive name'],
+      [ 'FAIL', 'SHEETZ',   'Caught case-insensitive name'],
+      [ 'FAIL', 'a' * 32,   'Caught long name'            ],
+      [ 'FAIL', '[',        'Caught invalid char'         ],
+      [ 'FAIL', ']',        'Caught invalid char'         ],
+      [ 'FAIL', ':',        'Caught invalid char'         ],
+      [ 'FAIL', '*',        'Caught invalid char'         ],
+      [ 'FAIL', '?',        'Caught invalid char'         ],
+      [ 'FAIL', '/',        'Caught invalid char'         ],
+      [ 'FAIL', '\\',       'Caught invalid char'         ]
+    ]
+  end
+
+  def test_add_format_must_accept_one_or_more_hash_params
+    font    = {
+      :font   => 'ＭＳ 明朝',
+      :size   => 12,
+      :color  => 'blue',
+      :bold   => 1
+    }
+    shading = {
+      :bg_color => 'green',
+      :pattern  => 1
+    }
+    properties = font.merge(shading)
+
+    format1 = @workbook.add_format(properties)
+    format2 = @workbook.add_format(font, shading)
+    assert(format_equal?(format1, format2))
+  end
+
+  def format_equal?(f1, f2)
+    require 'yaml'
+    re = /xf_index: \d+\n/
+    YAML.dump(f1).sub(re, '') == YAML.dump(f2).sub(re, '')
+  end
+end

data/test/test_worksheet.rb

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+require 'helper'
+require 'stringio'
+
+class TC_Worksheet < Test::Unit::TestCase
+  TEST_DIR    = File.expand_path(File.dirname(__FILE__))
+  PERL_OUTDIR = File.join(TEST_DIR, 'perl_output')
+
+  def setup
+    @test_file = StringIO.new
+    @workbook = WriteExcel.new(@test_file)
+    @sheetname = 'test'
+    @ws      = @workbook.add_worksheet(@sheetname, 0)
+    @perldir = "#{PERL_OUTDIR}/"
+    @format  = Writeexcel::Format.new(:color=>"green")
+  end
+
+  def test_methods_exist
+    assert_respond_to(@ws, :write)
+    assert_respond_to(@ws, :write_blank)
+    assert_respond_to(@ws, :write_row)
+    assert_respond_to(@ws, :write_col)
+  end
+
+  def test_methods_no_error
+    assert_nothing_raised{ @ws.write(0,0,nil) }
+    assert_nothing_raised{ @ws.write(0,0,"Hello") }
+    assert_nothing_raised{ @ws.write(0,0,888) }
+    assert_nothing_raised{ @ws.write_row(0,0,["one","two","three"]) }
+    assert_nothing_raised{ @ws.write_row(0,0,[1,2,3]) }
+    assert_nothing_raised{ @ws.write_col(0,0,["one","two","three"]) }
+    assert_nothing_raised{ @ws.write_col(0,0,[1,2,3]) }
+    assert_nothing_raised{ @ws.write_blank(0,0,nil) }
+    assert_nothing_raised{ @ws.write_url(0,0,"http://www.ruby-lang.org") }
+  end
+
+  def test_write_syntax
+    assert_nothing_raised{@ws.write(0,0,"Hello")}
+    assert_nothing_raised{@ws.write(0,0,666)}
+  end
+
+  def test_store_dimensions
+    file = "delete_this"
+    File.open(file,"w+"){ |f| f.print @ws.__send__("store_dimensions") }
+    pf = @perldir + "ws_store_dimensions"
+    p_od = IO.readlines(pf).to_s.dump
+    r_od = IO.readlines(file).to_s.dump
+    assert_equal_filesize(pf ,file, "Invalid size for store_selection")
+    assert_equal(p_od, r_od,"Octal dumps are not identical")
+    File.delete(file)
+  end
+
+  def test_store_colinfo
+    colinfo = Writeexcel::Worksheet::ColInfo.new(0, 0, 8.43, nil, false, 0, false)
+
+    file = "delete_this"
+    File.open(file,"w+"){ |f| f.print @ws.__send__("store_colinfo", colinfo) }
+    pf = @perldir + "ws_store_colinfo"
+    p_od = IO.readlines(pf).to_s.dump
+    r_od = IO.readlines(file).to_s.dump
+    assert_equal_filesize(pf, file, "Invalid size for store_colinfo")
+    assert_equal(p_od,r_od,"Perl and Ruby octal dumps don't match")
+    File.delete(file)
+  end
+
+  def test_store_selection
+    file = "delete_this"
+    File.open(file,"w+"){ |f| f.print @ws.__send__("store_selection", 1,1,2,2) }
+    pf = @perldir + "ws_store_selection"
+    p_od = IO.readlines(pf).to_s.dump
+    r_od = IO.readlines(file).to_s.dump
+    assert_equal_filesize(pf, file, "Invalid size for store_selection")
+    assert_equal(p_od, r_od,"Octal dumps are not identical")
+    File.delete(file)
+  end
+
+  def test_store_filtermode
+    file = "delete_this"
+    File.open(file,"w+"){ |f| f.print @ws.__send__("store_filtermode") }
+    pf = @perldir + "ws_store_filtermode_off"
+    p_od = IO.readlines(pf).to_s.dump
+    r_od = IO.readlines(file).to_s.dump
+    assert_equal_filesize(pf, file, "Invalid size for store_filtermode_off")
+    assert_equal(p_od, r_od,"Octal dumps are not identical")
+    File.delete(file)
+
+    @ws.autofilter(1,1,2,2)
+    @ws.filter_column(1, 'x < 2000')
+    File.open(file,"w+"){ |f| f.print @ws.__send__("store_filtermode") }
+    pf = @perldir + "ws_store_filtermode_on"
+    p_od = IO.readlines(pf).to_s.dump
+    r_od = IO.readlines(file).to_s.dump
+    assert_equal_filesize(pf, file, "Invalid size for store_filtermode_off")
+    assert_equal(p_od, r_od,"Octal dumps are not identical")
+    File.delete(file)
+  end
+
+  def test_new
+    assert_equal(@sheetname, @ws.name)
+  end
+
+
+  def assert_equal_filesize(target, test, msg = "Bad file size")
+    assert_equal(File.size(target),File.size(test),msg)
+  end
+end