WriteExcel 0.2.0

data/test/tc_format.rb

@@ -0,0 +1,1264 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+
+require "test/unit"
+require "WriteExcel"
+
+class TC_Format < Test::Unit::TestCase
+
+  TEST_DIR    = File.expand_path(File.dirname(__FILE__))
+  PERL_OUTDIR = File.join(TEST_DIR, 'perl_output')
+
+  def setup
+    t = Time.now.strftime("%Y%m%d")
+    path = "temp#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
+    @ruby_file  = File.join(Dir.tmpdir, path)
+    @format = Format.new
+  end
+
+  def teardown
+    File.delete(@ruby_file) if File.exist?(@ruby_file)
+    @format = nil
+  end
+
+  def test_set_format_properties
+  end
+
+  def test_format_properties_with_valid_value
+    # set_format_properties( propty => val )
+    valid_properties = get_valid_format_properties
+    valid_properties.each do |k,v|
+      fmt = Format.new
+      before = get_format_property(fmt)
+      fmt.set_format_properties(k => v)
+      after  = get_format_property(fmt)
+      after.delete_if {|key, val| before[key] == val }
+      assert_equal(1, after.size, "change 1 property[:#{k}] but #{after.size} was changed.#{after.inspect}")
+      assert_equal(v, after[k], "[:#{k}] doesn't match.")
+    end
+
+    # set_format_properties( propty_1 => val1, propty_2 => val2)
+    valid_properties.each do |k,v|
+      fmt = Format.new
+      before = get_format_property(fmt)
+      fmt.set_format_properties(k => v, :bold => 1)
+      after  = get_format_property(fmt)
+      after.delete_if {|key, val| before[key] == val }
+      assert_equal(2, after.size, "change 1 property[:#{k}] but #{after.size} was changed.#{after.inspect}")
+      assert_equal(v, after[k], "[:#{k}] doesn't match.")
+      assert_equal(700, after[:bold])
+    end
+
+    # set_format_properties( hash_variable )
+    valid_properties = get_valid_format_properties
+    valid_properties.each do |k,v|
+      arg = {k => v}
+      fmt = Format.new
+      before = get_format_property(fmt)
+      fmt.set_format_properties(arg)
+      after  = get_format_property(fmt)
+      after.delete_if {|key, val| before[key] == val }
+      assert_equal(1, after.size, "change 1 property[:#{k}] but #{after.size} was changed.#{after.inspect}")
+      assert_equal(v, after[k], "[:#{k}] doesn't match.")
+    end
+
+    # set_format_properties( hash_variable, hash_variable... )
+    valid_properties = get_valid_format_properties
+    valid_properties.each do |k,v|
+      arg  = {k => v}
+      arg2 = {:bold => 1}
+      fmt = Format.new
+      before = get_format_property(fmt)
+      fmt.set_format_properties(arg, arg2)
+      after  = get_format_property(fmt)
+      after.delete_if {|key, val| before[key] == val }
+      assert_equal(2, after.size, "change 1 property[:#{k}] but #{after.size} was changed.#{after.inspect}")
+      assert_equal(v, after[k], "[:#{k}] doesn't match.")
+      assert_equal(700, after[:bold])
+    end
+
+    # set_color by string
+    valid_color_string_number = get_valid_color_string_number
+    [:color , :bg_color, :fg_color].each do |coltype|
+      valid_color_string_number.each do |str, num|
+        fmt = Format.new
+        before = get_format_property(fmt)
+        fmt.set_format_properties(coltype => str)
+        after  = get_format_property(fmt)
+        after.delete_if {|key, val| before[key] == val }
+        assert_equal(1, after.size, "change 1 property[:#{coltype}:#{str}] but #{after.size} was changed.#{after.inspect}")
+        assert_equal(num, after[:"#{coltype}"], "[:#{coltype}:#{str}] doesn't match.")
+      end
+    end
+
+
+  end
+
+  def test_format_properties_with_invalid_value
+  end
+
+  def test_set_font
+  end
+
+=begin
+set_size()
+    Default state:      Font size is 10
+    Default action:     Set font size to 1
+    Valid args:         Integer values from 1 to as big as your screen.
+Set the font size. Excel adjusts the height of a row to accommodate the largest font size in the row. You can also explicitly specify the height of a row using the set_row() worksheet method.
+=end
+  def test_set_size
+    # default state
+    assert_equal(10, @format.size)
+
+    # valid size from low to high
+    [1, 100, 100**10].each do |size|
+      fmt = Format.new
+      fmt.set_size(size)
+      assert_equal(size, fmt.size, "valid size:#{size} - doesn't match.")
+    end
+
+    # invalid size  -- size doesn't change
+    [-1, 0, 1/2.0, 'hello', true, false, nil, [0,0], {:invalid => "val"}].each do |size|
+      fmt = Format.new
+      default = fmt.size
+      fmt.set_size(size)
+      assert_equal(default, fmt.size, "size:#{size.inspect} doesn't match.")
+    end
+  end
+
+=begin
+set_color()
+
+    Default state:      Excels default color, usually black
+    Default action:     Set the default color
+    Valid args:         Integers from 8..63 or the following strings:
+                        'black'
+                        'blue'
+                        'brown'
+                        'cyan'
+                        'gray'
+                        'green'
+                        'lime'
+                        'magenta'
+                        'navy'
+                        'orange'
+                        'pink'
+                        'purple'
+                        'red'
+                        'silver'
+                        'white'
+                        'yellow'
+
+Set the font colour. The set_color() method is used as follows:
+
+    format = workbook.add_format()
+    format.set_color('red')
+    worksheet.write(0, 0, 'wheelbarrow', format)
+
+Note: The set_color() method is used to set the colour of the font in a cell. 
+To set the colour of a cell use the set_bg_color() and set_pattern() methods.
+=end
+  def test_set_color
+    # default state
+    default_col = 0x7FFF
+    assert_equal(default_col, @format.color)
+
+    # valid color
+    # set by string
+    str_num = get_valid_color_string_number
+    str_num.each do |str,num|
+      fmt = Format.new
+      fmt.set_color(str)
+      assert_equal(num, fmt.color)
+    end
+
+    # valid color
+    # set by number
+    [8, 36, 63].each do |color|
+      fmt = Format.new
+      fmt.set_color(color)
+      assert_equal(color, fmt.color)
+    end
+
+    # invalid color
+    ['color', :col, -1, 63.5, 10*10].each do |color|
+      fmt = Format.new
+      fmt.set_color(color)
+      assert_equal(default_col, fmt.color, "color : #{color}")
+    end
+
+    # invalid color    ...but...
+    # 0 <= color < 8  then color += 8 in order to valid value
+    [0, 7.5].each do |color|
+      fmt = Format.new
+      fmt.set_color(color)
+      assert_equal((color + 8).to_i, fmt.color, "color : #{color}")
+    end
+
+
+  end
+
+=begin
+set_bold()
+
+    Default state:      bold is off  (internal value = 400)
+    Default action:     Turn bold on
+    Valid args:         0, 1 [1]
+
+Set the bold property of the font:
+
+    $format->set_bold();  # Turn bold on
+
+[1] Actually, values in the range 100..1000 are also valid.
+    400 is normal, 700 is bold and 1000 is very bold indeed.
+    It is probably best to set the value to 1 and use normal bold.
+=end
+
+  def test_set_bold
+    # default state
+    assert_equal(400, @format.bold)
+
+    # valid weight
+    fmt = Format.new
+    fmt.set_bold
+    assert_equal(700, fmt.bold)
+    {0 => 400, 1 => 700, 100 => 100, 1000 => 1000}.each do |weight, value|
+      fmt = Format.new
+      fmt.set_bold(weight)
+      assert_equal(value, fmt.bold)
+    end
+
+    # invalid weight
+    [-1, 99, 1001, 'bold'].each do |weight|
+      fmt = Format.new
+      fmt.set_bold(weight)
+      assert_equal(400, fmt.bold, "weight : #{weight}")
+    end
+  end
+
+=begin
+set_italic()
+
+    Default state:      Italic is off
+    Default action:     Turn italic on
+    Valid args:         0, 1
+
+ Set the italic property of the font:
+
+    format.set_italic()  # Turn italic on
+=end
+  def test_set_italic
+    # default state
+    assert_equal(0, @format.italic)
+
+    # valid arg
+    fmt = Format.new
+    fmt.set_italic
+    assert_equal(1, fmt.italic)
+    {0=>0, 1=>1}.each do |arg,value|
+      fmt = Format.new
+      fmt.set_italic(arg)
+      assert_equal(value, fmt.italic, "arg : #{arg}")
+    end
+
+    # invalid arg
+    [-1, 0.2, 100, 'italic', true, false, nil].each do |arg|
+      assert_raise(ArgumentError,
+      "set_italic(#{arg}) : invalid arg. arg must be 0, 1 or none."){
+        fmt = Format.new
+        fmt.set_italic(arg)
+      }
+    end
+  end
+
+=begin
+set_underline()
+
+    Default state:      Underline is off
+    Default action:     Turn on single underline
+    Valid args:         0  = No underline
+                        1  = Single underline
+                        2  = Double underline
+                        33 = Single accounting underline
+                        34 = Double accounting underline
+
+Set the underline property of the font.
+
+    format.set_underline()   # Single underline
+=end
+  def test_set_underline
+    # default state
+    assert_equal(0, @format.underline, "default state")
+
+    # valid args
+    fmt = Format.new
+    fmt.set_underline
+    assert_equal(1, fmt.underline, "No arg")
+
+    [0, 1, 2, 33, 34].each do |arg|
+      fmt = Format.new
+      fmt.set_underline(arg)
+      assert_equal(arg, fmt.underline, "arg : #{arg}")
+    end
+
+    # invalid args
+    [-1, 0.2, 100, 'under', true, false, nil].each do |arg|
+      assert_raise(ArgumentError,
+      "set_underline(#{arg}) : arg must be 0, 1 or none, 2, 33, 34."){
+        fmt = Format.new
+        fmt.set_underline(arg)
+      }
+    end
+  end
+
+=begin
+set_font_strikeout()
+
+    Default state:      Strikeout is off
+    Default action:     Turn strikeout on
+    Valid args:         0, 1
+
+Set the strikeout property of the font.
+=end
+  def test_set_font_strikeout
+    # default state
+    assert_equal(0, @format.font_strikeout, "default state")
+
+    # valid args
+    fmt = Format.new
+    fmt.set_font_strikeout
+    assert_equal(1, fmt.font_strikeout, "No arg")
+
+    [0, 1].each do |arg|
+      fmt = Format.new
+      fmt.set_font_strikeout(arg)
+      assert_equal(arg, fmt.font_strikeout, "arg : #{arg}")
+    end
+
+    # invalid args
+    [-1, 0.2, 100, 'strikeout', true, false, nil].each do |arg|
+      assert_raise(ArgumentError,
+      "set_font_strikeout(#{arg}) : arg must be 0, 1 or none."){
+        fmt = Format.new
+        fmt.set_font_strikeout(arg)
+      }
+    end
+  end
+
+=begin
+set_font_script()
+
+    Default state:      Super/Subscript is off
+    Default action:     Turn Superscript on
+    Valid args:         0  = Normal
+                        1  = Superscript
+                        2  = Subscript
+
+Set the superscript/subscript property of the font. This format is currently not very useful.
+=end
+  def test_set_font_script
+    # default state
+    assert_equal(0, @format.font_script, "default state")
+
+    # valid args
+    fmt = Format.new
+    fmt.set_font_script
+    assert_equal(1, fmt.font_script, "No arg")
+
+    [0, 1, 2].each do |arg|
+      fmt = Format.new
+      fmt.set_font_script(arg)
+      assert_equal(arg, fmt.font_script, "arg : #{arg}")
+    end
+
+    # invalid args
+    [-1, 0.2, 100, 'script', true, false, nil].each do |arg|
+      assert_raise(ArgumentError,
+      "set_font_script(#{arg}) : arg must be 0, 1 or none, or 2."){
+        fmt = Format.new
+        fmt.set_font_script(arg)
+      }
+    end
+
+  end
+
+=begin
+set_font_outline()
+
+    Default state:      Outline is off
+    Default action:     Turn outline on
+    Valid args:         0, 1
+
+Macintosh only.
+=end
+  def test_set_font_outline
+    # default state
+    assert_equal(0, @format.font_outline, "default state")
+
+    # valid args
+    fmt = Format.new
+    fmt.set_font_outline
+    assert_equal(1, fmt.font_outline, "No arg")
+
+    [0, 1].each do |arg|
+      fmt = Format.new
+      fmt.set_font_outline(arg)
+      assert_equal(arg, fmt.font_outline, "arg : #{arg}")
+    end
+
+    # invalid args
+    [-1, 0.2, 100, 'outline', true, false, nil].each do |arg|
+      assert_raise(ArgumentError,
+      "set_font_outline(#{arg}) : arg must be 0, 1 or none."){
+        fmt = Format.new
+        fmt.set_font_outline(arg)
+      }
+    end
+  end
+
+=begin
+set_font_shadow()
+
+    Default state:      Shadow is off
+    Default action:     Turn shadow on
+    Valid args:         0, 1
+
+Macintosh only.
+=end
+  def test_set_font_shadow
+    # default state
+    assert_equal(0, @format.font_shadow, "default state")
+
+    # valid args
+    fmt = Format.new
+    fmt.set_font_shadow
+    assert_equal(1, fmt.font_shadow, "No arg")
+
+    [0, 1].each do |arg|
+      fmt = Format.new
+      fmt.set_font_shadow(arg)
+      assert_equal(arg, fmt.font_shadow, "arg : #{arg}")
+    end
+
+    # invalid args
+    [-1, 0.2, 100, 'shadow', true, false, nil].each do |arg|
+      assert_raise(ArgumentError,
+      "set_font_shadow(#{arg}) : arg must be 0, 1 or none."){
+        fmt = Format.new
+        fmt.set_font_shadow(arg)
+      }
+    end
+  end
+
+=begin
+set_num_format()
+
+    Default state:      General format
+    Default action:     Format index 1
+    Valid args:         See the following table
+
+This method is used to define the numerical format of a number in Excel. It controls whether a number is displayed as an integer, a floating point number, a date, a currency value or some other user defined format.
+=end
+  def test_set_num_format
+    # default state
+    assert_equal(0, @format.num_format)
+
+    # Excel built in Format Index (0 .. 49)
+    [0, 49].each do |n|
+      fmt = Format.new
+      fmt.set_num_format(n)
+      assert_equal(n, fmt.num_format, "n: #{n}")
+    end
+
+    # Format string
+    ["#,##0", "m/d/yy", "hh:mm:ss"].each do |string|
+      fmt = Format.new
+      fmt.set_num_format(string)
+      assert_equal(string, fmt.num_format, "string: #{string}")
+    end
+  end
+
+=begin
+set_locked()
+
+    Default state:      Cell locking is on
+    Default action:     Turn locking on
+    Valid args:         0, 1
+
+This property can be used to prevent modification of a cells
+ contents. Following Excel's convention, cell locking is 
+ turned on by default. However, it only has an effect if 
+ the worksheet has been protected, see the worksheet protect()
+  method.
+
+    locked  = workbook.add_format()
+    locked.set_locked(1)  # A non-op
+
+    unlocked = workbook.add_format()
+    locked.set_locked(0)
+
+    # Enable worksheet protection
+    worksheet.protect()
+
+    # This cell cannot be edited.
+    worksheet.write('A1', '=1+2', locked)
+
+    # This cell can be edited.
+    worksheet->write('A2', '=1+2', unlocked)
+
+Note: This offers weak protection even with a password,
+ see the note in relation to the protect() method.
+=end
+  def test_set_locked
+    # default state
+    assert_equal(1, @format.locked, "default state")
+
+    # valid args
+    fmt = Format.new
+    fmt.set_locked
+    assert_equal(1, fmt.locked, "No arg")
+
+    [0, 1].each do |arg|
+      fmt = Format.new
+      fmt.set_locked(arg)
+      assert_equal(arg, fmt.locked, "arg : #{arg}")
+    end
+
+    # invalid args
+    [-1, 0.2, 100, 'locked', true, false, nil].each do |arg|
+      assert_raise(ArgumentError,
+      "set_font_shadow(#{arg}) : arg must be 0, 1 or none."){
+        fmt = Format.new
+        fmt.set_locked(arg)
+      }
+    end
+  end
+=begin
+set_hidden()
+
+    Default state:      Formula hiding is off
+    Default action:     Turn hiding on
+    Valid args:         0, 1
+
+This property is used to hide a formula while still displaying
+ its result. This is generally used to hide complex calculations
+ from end users who are only interested in the result.
+ It only has an effect if the worksheet has been protected,
+ see the worksheet protect() method.
+
+    my hidden = workbook.add_format()
+    hidden.set_hidden()
+
+    # Enable worksheet protection
+    worksheet.protect()
+
+    # The formula in this cell isn't visible
+    worksheet.write('A1', '=1+2', hidden)
+
+Note: This offers weak protection even with a password,
+ see the note in relation to the protect() method.
+=end
+  def test_set_hidden
+    # default state
+    assert_equal(0, @format.hidden, "default state")
+
+    # valid args
+    fmt = Format.new
+    fmt.set_hidden
+    assert_equal(1, fmt.hidden, "No arg")
+
+    [0, 1].each do |arg|
+      fmt = Format.new
+      fmt.set_hidden(arg)
+      assert_equal(arg, fmt.hidden, "arg : #{arg}")
+    end
+
+    # invalid args
+    [-1, 0.2, 100, 'hidden', true, false, nil].each do |arg|
+      assert_raise(ArgumentError,
+      "set_font_shadow(#{arg}) : arg must be 0, 1 or none."){
+        fmt = Format.new
+        fmt.set_hidden(arg)
+      }
+    end
+  end
+
+=begin
+set_align()
+
+    Default state:      Alignment is off
+    Default action:     Left alignment
+    Valid args:         'left'              Horizontal
+                        'center'
+                        'right'
+                        'fill'
+                        'justify'
+                        'center_across'
+
+                        'top'               Vertical
+                        'vcenter'
+                        'bottom'
+                        'vjustify'
+
+This method is used to set the horizontal and vertical text alignment
+within a cell. Vertical and horizontal alignments can be combined.
+ The method is used as follows:
+
+    my $format = $workbook->add_format();
+    $format->set_align('center');
+    $format->set_align('vcenter');
+    $worksheet->set_row(0, 30);
+    $worksheet->write(0, 0, 'X', $format);
+
+Text can be aligned across two or more adjacent cells using
+the center_across property. However, for genuine merged cells
+it is better to use the merge_range() worksheet method.
+
+The vjustify (vertical justify) option can be used to provide
+automatic text wrapping in a cell. The height of the cell will be
+adjusted to accommodate the wrapped text. To specify where the text
+wraps use the set_text_wrap() method.
+=end
+  def test_set_align
+    # default state
+    assert_equal(0, @format.text_h_align)
+    assert_equal(2, @format.text_v_align)
+
+    # valid arg
+    valid_args = {'left'=>1, 'center'=>2, 'centre'=>2, 'right'=>3,
+      'fill'=>4, 'justify'=>5, 'center_across'=>6,
+      'centre_across'=>6, 'merge'=>6,
+      'top'=>0, 'vcenter'=>1, 'vcentre'=>1, 'bottom'=>2,
+    'vjustify'=>3 }
+    valid_args.each do |arg, value|
+      fmt = Format.new
+      fmt.set_align(arg)
+      case arg
+      when 'left', 'center', 'centre', 'right', 'fill', 'justify',
+        'center_across', 'centre_across', 'merge'
+        assert_equal(value, fmt.text_h_align, "arg: #{arg}")
+      when 'top', 'vcenter', 'vcentre', 'bottom', 'vjustify'
+        assert_equal(value, fmt.text_v_align, "arg: #{arg}")
+      end
+    end
+
+    # invalid arg
+    [-1, 0, 1.5, nil, true, false, ['left','top'], {'top'=>0}].each do |arg|
+      fmt = Format.new
+      val = get_format_property(fmt)
+      #print val.inspect
+      #exit
+      fmt.set_align(arg)
+      assert_equal(val[:align], fmt.text_h_align, "arg: #{arg} - text_h_align changed.")
+      assert_equal(val[:valign], fmt.text_v_align, "arg: #{arg} - text_v_align changed.")
+    end
+  end
+
+=begin
+set_center_across()
+
+    Default state:      Center across selection is off
+    Default action:     Turn center across on
+    Valid args:         1
+
+Text can be aligned across two or more adjacent cells
+using the set_center_across() method. This is an alias
+for the set_align('center_across') method call.
+
+Only one cell should contain the text,
+the other cells should be blank:
+
+    format = workbook.add_format()
+    format.set_center_across()
+
+    worksheet.write(1, 1, 'Center across selection', format)
+    worksheet.write_blank(1, 2, format)
+=end
+  def test_set_center_across
+    # default state
+    assert_equal(0, @format.text_h_align)
+
+    # method call then center_across is set. if arg is none, numeric, string, whatever.
+    @format.set_center_across
+    assert_equal(6, @format.text_h_align)
+  end
+
+=begin
+set_text_wrap()
+
+    Default state:      Text wrap is off
+    Default action:     Turn text wrap on
+    Valid args:         0, 1
+
+ Here is an example using the text wrap property, the escape
+ character \n is used to indicate the end of line:
+
+    format = workbook.add_format()
+    format.set_text_wrap()
+    worksheet.write(0, 0, "It's\na bum\nwrap", format)
+=end
+  def test_set_text_wrap
+    # default state
+    assert_equal(0, @format.text_wrap, "default state")
+
+    # valid args
+    fmt = Format.new
+    fmt.set_text_wrap
+    assert_equal(1, fmt.text_wrap, "No arg")
+
+    [0, 1].each do |arg|
+      fmt = Format.new
+      fmt.set_text_wrap(arg)
+      assert_equal(arg, fmt.text_wrap, "arg : #{arg}")
+    end
+
+    # invalid args
+    [-1, 0.2, 100, 'text_wrap', true, false, nil].each do |arg|
+      assert_raise(ArgumentError,
+      "set_text_wrap(#{arg}) : arg must be 0, 1 or none."){
+        fmt = Format.new
+        fmt.set_text_wrap(arg)
+      }
+    end
+  end
+
+=begin
+set_rotation()
+
+    Default state:      Text rotation is off
+    Default action:     None
+    Valid args:         Integers in the range -90 to 90 and 270
+
+ Set the rotation of the text in a cell. The rotation can be
+ any angle in the range -90 to 90 degrees.
+
+    format = workbook.add_format()
+    format.set_rotation(30)
+    worksheet.write(0, 0, 'This text is rotated', format)
+
+ The angle 270 is also supported. This indicates text where
+ the letters run from top to bottom.
+=end
+  def test_set_rotation
+    # default state
+    assert(0, @format.rotation)
+
+    #      # valid args  -90 <= angle <=  90, 270   angle can be float or double
+    #      [-90.0, 89, 0, 89, 90, 270].each do |angle|
+    #         fmt = Format.new
+    #         fmt.set_rotation(angle)
+    #         assert_equal(angle, fmt.rotation, "angle: #{angle}")
+    #      end
+  end
+
+=begin
+set_indent()
+
+    Default state:      Text indentation is off
+    Default action:     Indent text 1 level
+    Valid args:         Positive integers
+
+This method can be used to indent text. The argument, which should
+be an integer, is taken as the level of indentation:
+
+    format = workbook.add_format()
+    format.set_indent(2)
+    worksheet.write(0, 0, 'This text is indented', format)
+
+Indentation is a horizontal alignment property. It will override
+any other horizontal properties but it can be used in conjunction
+with vertical properties.
+=end
+  def test_set_indent
+    # default state
+    assert_equal(0, @format.indent)
+
+    # valid arg -- Positive integers
+    [1, 10000000].each do |indent|
+      fmt = Format.new
+      fmt.set_indent(indent)
+      assert_equal(indent, fmt.indent, "indent: #{indent}")
+    end
+
+    # invalid arg
+    [].each do |indent|
+
+    end
+  end
+
+=begin
+set_shrink()
+
+    Default state:      Text shrinking is off
+    Default action:     Turn "shrink to fit" on
+    Valid args:         1
+
+ This method can be used to shrink text so that it fits in a cell.
+
+    format = workbook.add_format()
+    format.set_shrink()
+    worksheet.write(0, 0, 'Honey, I shrunk the text!', format)
+=end
+  def test_set_shrink
+    # default state
+    assert_equal(0, @format.shrink)
+  end
+
+=begin
+set_text_justlast()
+
+    Default state:      Justify last is off
+    Default action:     Turn justify last on
+    Valid args:         0, 1
+
+Only applies to Far Eastern versions of Excel.
+=end
+  def test_set_text_justlast
+    # default state
+    assert_equal(0, @format.text_justlast)
+  end
+
+=begin
+set_pattern()
+
+    Default state:      Pattern is off
+    Default action:     Solid fill is on
+    Valid args:         0 .. 18
+
+Set the background pattern of a cell.
+=end
+  def test_set_pattern
+    # default state
+    assert_equal(0, @format.pattern)
+  end
+
+=begin
+set_bg_color()
+
+    Default state:      Color is off
+    Default action:     Solid fill.
+    Valid args:         See set_color()
+
+The set_bg_color() method can be used to set the background
+colour of a pattern. Patterns are defined via the set_pattern()
+method. If a pattern hasn't been defined then a solid fill
+pattern is used as the default.
+
+Here is an example of how to set up a solid fill in a cell:
+
+    format = workbook.add_format()
+    format.set_pattern() # This is optional when using a solid fill
+    format.set_bg_color('green')
+    worksheet.write('A1', 'Ray', format)
+=end
+  def test_set_bg_color
+  end
+
+=begin
+set_fg_color()
+
+    Default state:      Color is off
+    Default action:     Solid fill.
+    Valid args:         See set_color()
+
+The set_fg_color() method can be used to set
+ the foreground colour of a pattern.
+=end
+  def test_set_fg_color
+  end
+
+=begin
+set_border()
+
+    Also applies to:    set_bottom()
+                        set_top()
+                        set_left()
+                        set_right()
+
+    Default state:      Border is off
+    Default action:     Set border type 1
+    Valid args:         0-13, See below.
+
+A cell border is comprised of a border on the bottom, top,
+left and right. These can be set to the same value using
+set_border() or individually using the relevant method
+calls shown above.
+
+The following shows the border styles sorted
+by Spreadsheet::WriteExcel index number:
+
+    Index   Name            Weight   Style
+    =====   =============   ======   ===========
+    0       None            0
+    1       Continuous      1        -----------
+    2       Continuous      2        -----------
+    3       Dash            1        - - - - - -
+    4       Dot             1        . . . . . .
+    5       Continuous      3        -----------
+    6       Double          3        ===========
+    7       Continuous      0        -----------
+    8       Dash            2        - - - - - -
+    9       Dash Dot        1        - . - . - .
+    10      Dash Dot        2        - . - . - .
+    11      Dash Dot Dot    1        - . . - . .
+    12      Dash Dot Dot    2        - . . - . .
+    13      SlantDash Dot   2        / - . / - .
+
+The following shows the borders sorted by style:
+
+    Name            Weight   Style         Index
+    =============   ======   ===========   =====
+    Continuous      0        -----------   7
+    Continuous      1        -----------   1
+    Continuous      2        -----------   2
+    Continuous      3        -----------   5
+    Dash            1        - - - - - -   3
+    Dash            2        - - - - - -   8
+    Dash Dot        1        - . - . - .   9
+    Dash Dot        2        - . - . - .   10
+    Dash Dot Dot    1        - . . - . .   11
+    Dash Dot Dot    2        - . . - . .   12
+    Dot             1        . . . . . .   4
+    Double          3        ===========   6
+    None            0                      0
+    SlantDash Dot   2        / - . / - .   13
+
+The following shows the borders in the order shown in the Excel Dialog.
+
+    Index   Style             Index   Style
+    =====   =====             =====   =====
+    0       None              12      - . . - . .
+    7       -----------       13      / - . / - .
+    4       . . . . . .       10      - . - . - .
+    11      - . . - . .       8       - - - - - -
+    9       - . - . - .       2       -----------
+    3       - - - - - -       5       -----------
+    1       -----------       6       ===========
+=end
+  def test_set_border
+  end
+
+=begin
+set_border_color()
+
+    Also applies to:    set_bottom_color()
+                        set_top_color()
+                        set_left_color()
+                        set_right_color()
+
+    Default state:      Color is off
+    Default action:     Undefined
+    Valid args:         See set_color()
+
+Set the colour of the cell borders. A cell border is comprised of a border
+on the bottom, top, left and right. These can be set to the same colour
+using set_border_color() or individually using the relevant method
+calls shown above. 
+=end
+  def test_set_border_color
+  end
+
+=begin
+copy($format)
+
+This method is used to copy all of the properties
+from one Format object to another:
+
+    lorry1 = workbook.add_format()
+    lorry1.set_bold()
+    lorry1.set_italic()
+    lorry1.set_color('red')    # lorry1 is bold, italic and red
+
+    my lorry2 = workbook.add_format()
+    lorry2.copy(lorry1)
+    lorry2.set_color('yellow') # lorry2 is bold, italic and yellow
+
+The copy() method is only useful if you are using the method interface
+to Format properties. It generally isn't required if you are setting
+Format properties directly using hashes.
+
+Note: this is not a copy constructor, both objects must exist prior to copying.
+=end
+
+  def test_xf_biff_size
+    perl_file = "#{PERL_OUTDIR}/file_xf_biff"
+    size = File.size(perl_file)
+    @fh = File.new(@ruby_file,"w+")
+    @fh.print(@format.get_xf)
+    @fh.close
+    rsize = File.size(@ruby_file)
+    assert_equal(size,rsize,"File sizes not the same")
+
+  end
+
+  # Because of the modifications to bg_color and fg_color, I know this
+  # test will fail.  This is ok.
+  #def test_xf_biff_contents
+  #   perl_file = "perl_output/f_xf_biff"
+  #   @fh = File.new(@ruby_file,"w+")
+  #   @fh.print(@format.xf_biff)
+  #   @fh.close
+  #   contents = IO.readlines(perl_file)
+  #   rcontents = IO.readlines(@ruby_file)
+  #   assert_equal(contents,rcontents,"Contents not the same")
+  #end
+
+  def test_font_biff_size
+    perl_file = "#{PERL_OUTDIR}/file_font_biff"
+    @fh = File.new(@ruby_file,"w+")
+    @fh.print(@format.get_font)
+    @fh.close
+    contents = IO.readlines(perl_file)
+    rcontents = IO.readlines(@ruby_file)
+    assert_equal(contents,rcontents,"Contents not the same")
+  end
+
+  def test_font_biff_contents
+    perl_file = "#{PERL_OUTDIR}/file_font_biff"
+    @fh = File.new(@ruby_file,"w+")
+    @fh.print(@format.get_font)
+    @fh.close
+    contents = IO.readlines(perl_file)
+    rcontents = IO.readlines(@ruby_file)
+    assert_equal(contents,rcontents,"Contents not the same")
+  end
+
+  def test_get_font_key_size
+    perl_file = "#{PERL_OUTDIR}/file_font_key"
+    @fh = File.new(@ruby_file,"w+")
+    @fh.print(@format.get_font_key)
+    @fh.close
+    assert_equal(File.size(perl_file),File.size(@ruby_file),"Bad file size")
+  end
+
+  def test_get_font_key_contents
+    perl_file = "#{PERL_OUTDIR}/file_font_key"
+    @fh = File.new(@ruby_file,"w+")
+    @fh.print(@format.get_font_key)
+    @fh.close
+    contents = IO.readlines(perl_file)
+    rcontents = IO.readlines(@ruby_file)
+    assert_equal(contents,rcontents,"Contents not the same")
+  end
+
+  def test_initialize
+    assert_nothing_raised {
+      Format.new(:bold => true, :size => 10, :color => 'black',
+      :fg_color => 43, :align => 'top', :text_wrap => true,
+      :border => 1)
+    }
+  end
+
+  # added by Nakamura
+
+  def test_get_xf
+    perl_file = "#{PERL_OUTDIR}/file_xf_biff"
+    size = File.size(perl_file)
+    @fh = File.new(@ruby_file,"w+")
+    @fh.print(@format.get_xf)
+    @fh.close
+    rsize = File.size(@ruby_file)
+    assert_equal(size,rsize,"File sizes not the same")
+
+    fh_p = File.open(perl_file, "r")
+    fh_r = File.open(@ruby_file, "r")
+    while true do
+      p1 = fh_p.read(1)
+      r1 = fh_r.read(1)
+      if p1.nil?
+        assert( r1.nil?, 'p1 is EOF but r1 is NOT EOF.')
+        break
+      elsif r1.nil?
+        assert( p1.nil?, 'r1 is EOF but p1 is NOT EOF.')
+        break
+      end
+      assert_equal(p1, r1, sprintf(" p1 = %s but r1 = %s", p1, r1))
+      break
+    end
+    fh_p.close
+    fh_r.close
+  end
+
+  def test_get_font
+    perl_file = "#{PERL_OUTDIR}/file_font_biff"
+    size = File.size(perl_file)
+    @fh = File.new(@ruby_file,"w+")
+    @fh.print(@format.get_font)
+    @fh.close
+    rsize = File.size(@ruby_file)
+    assert_equal(size,rsize,"File sizes not the same")
+
+    fh_p = File.open(perl_file, "r")
+    fh_r = File.open(@ruby_file, "r")
+    while true do
+      p1 = fh_p.read(1)
+      r1 = fh_r.read(1)
+      if p1.nil?
+        assert( r1.nil?, 'p1 is EOF but r1 is NOT EOF.')
+        break
+      elsif r1.nil?
+        assert( p1.nil?, 'r1 is EOF but p1 is NOT EOF.')
+        break
+      end
+      assert_equal(p1, r1, sprintf(" p1 = %s but r1 = %s", p1, r1))
+      break
+    end
+    fh_p.close
+    fh_r.close
+  end
+
+  def test_get_font_key
+    perl_file = "#{PERL_OUTDIR}/file_font_key"
+    size = File.size(perl_file)
+    @fh = File.new(@ruby_file,"w+")
+    @fh.print(@format.get_font_key)
+    @fh.close
+    rsize = File.size(@ruby_file)
+    assert_equal(size,rsize,"File sizes not the same")
+
+    fh_p = File.open(perl_file, "r")
+    fh_r = File.open(@ruby_file, "r")
+    while true do
+      p1 = fh_p.read(1)
+      r1 = fh_r.read(1)
+      if p1.nil?
+        assert( r1.nil?, 'p1 is EOF but r1 is NOT EOF.')
+        break
+      elsif r1.nil?
+        assert( p1.nil?, 'r1 is EOF but p1 is NOT EOF.')
+        break
+      end
+      assert_equal(p1, r1, sprintf(" p1 = %s but r1 = %s", p1, r1))
+      break
+    end
+    fh_p.close
+    fh_r.close
+  end
+
+  def test_get_xf_index
+  end
+
+  def test_get_color
+  end
+
+  def test_method_missing
+  end
+
+  def test_copy
+    format1 = Format.new
+    format2 = Format.new
+    
+    format1.set_size(12)
+    
+    format2.copy(format1)
+    
+    assert_equal(format1.size, format2.size)
+  end
+
+
+  # -----------------------------------------------------------------------------
+
+  def get_valid_format_properties
+    {
+      :font           => 'Times New Roman',
+      :size           => 30,
+      :color          => 8,
+      :italic         => 1,
+      :underline      => 1,
+      :font_strikeout => 1,
+      :font_script    => 1,
+      :font_outline   => 1,
+      :font_shadow    => 1,
+      :locked         => 0,
+      :hidden         => 1,
+      :text_wrap      => 1,
+      :text_justlast  => 1,
+      :indent         => 2,
+      :shrink         => 1,
+      :pattern        => 18,
+      :bg_color       => 30,
+      :fg_color       => 63
+    }
+  end
+
+  def get_valid_color_string_number
+    return {
+      'black'     =>    8,
+      'blue'      =>   12,
+      'brown'     =>   16,
+      'cyan'      =>   15,
+      'gray'      =>   23,
+      'green'     =>   17,
+      'lime'      =>   11,
+      'magenta'   =>   14,
+      'navy'      =>   18,
+      'orange'    =>   53,
+      'pink'      =>   33,
+      'purple'    =>   20,
+      'red'       =>   10,
+      'silver'    =>   22,
+      'white'     =>    9,
+      'yellow'    =>   13
+    }
+  end
+  #         :rotation => -90,
+  #         :center_across => 1,
+  #         :align => 'left',
+
+  def get_format_property(format)
+    text_h_align = {
+      1 => 'left',
+      2 => 'center/centre',
+      3 => 'right',
+      4 => 'fill',
+      5 => 'justiry',
+      6 => 'center_across/centre_across/merge',
+      7 => 'distributed/equal_space'
+    }
+
+    text_v_align = {
+      0 => 'top',
+      1 => 'vcenter/vcentre',
+      2 => 'bottom',
+      3 => 'vjustify',
+      4 => 'vdistributed/vequal_space'
+    }
+
+    return {
+      :font                => format.font,
+      :size                => format.size,
+      :color               => format.color,
+      :bold                => format.bold,
+      :italic              => format.italic,
+      :underline           => format.underline,
+      :font_strikeout      => format.font_strikeout,
+      :font_script         => format.font_script,
+      :font_outline        => format.font_outline,
+      :font_shadow         => format.font_shadow,
+      :num_format          => format.num_format,
+      :locked              => format.locked,
+      :hidden              => format.hidden,
+      :align               => format.text_h_align,
+      :valign              => format.text_v_align,
+      :rotation            => format.rotation,
+      :text_wrap           => format.text_wrap,
+      :text_justlast       => format.text_justlast,
+      :center_across       => format.text_h_align,
+      :indent              => format.indent,
+      :shrink              => format.shrink,
+      :pattern             => format.pattern,
+      :bg_color            => format.bg_color,
+      :fg_color            => format.fg_color,
+      :border              => format.border,
+      :bottom              => format.bottom,
+      :top                 => format.top,
+      :left                => format.left,
+      :right               => format.right,
+      :bottom_color        => format.bottom_color,
+      :top_color           => format.top_color,
+      :left_color          => format.left_color,
+      :right_color         => format.right_color
+    }
+  end
+
+end