rubyXL-ptr 3.3.27

data/spec/lib/color_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe RubyXL::Color do
+  describe '.validate_color' do
+    it 'should return true if a valid hex color without a # is passed' do
+      expect(RubyXL::Color.validate_color('0fbCAd')).to eq(true)
+    end
+
+    it 'should cause an error if an invalid hex color code or one with a # is passed' do
+      expect {RubyXL::Color.validate_color('#G')}.to raise_error(RuntimeError)
+    end
+  end
+end

data/spec/lib/parser_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'tmpdir'
+
+describe RubyXL::Parser do
+
+  before do
+    @test_sheet_name = "This is a very long sheet name that should be trimmed to 31 characters for compatibility with MS Excel"
+    @workbook = RubyXL::Workbook.new
+    @workbook.add_worksheet("Test Worksheet")
+    @time = Time.at(Time.now.to_i) # Excel only saves times with 1-second precision.
+    @time2 = @time + 123456
+
+    ws = @workbook.add_worksheet("Escape Test")
+    ws.add_cell(0, 0, "&")
+    ws.add_cell(0, 1, "<")
+    ws.add_cell(0, 2, ">")
+    ws.add_cell(0, 3, "")
+
+    ws.add_cell(1, 0, "&")#TODO#.datatype = RubyXL::Cell::SHARED_STRING
+    ws.add_cell(1, 1, "<")#TODO#.datatype = RubyXL::Cell::SHARED_STRING
+    ws.add_cell(1, 2, ">")#TODO#.datatype = RubyXL::Cell::SHARED_STRING
+    ws.add_cell(1, 3, "")
+
+    ws.add_cell(2, 0, 0)
+    ws.add_cell(2, 1, 12345)
+    ws.add_cell(2, 2, 123.456e78)
+    ws.add_cell(2, 3, 123.456e-78)
+
+    ws.add_cell(3, 0, -0)
+    ws.add_cell(3, 1, -12345)
+    ws.add_cell(3, 2, -123.456e78)
+    ws.add_cell(3, 3, -123.456e-78)
+
+    ws[3][3].set_number_format('#.###')
+
+    @workbook.add_worksheet(@test_sheet_name)
+
+    @workbook.creator = "test creator"
+    @workbook.modifier = "test modifier"
+    @workbook.created_at = @time
+    @workbook.modified_at = @time2
+
+    @time_str = Time.now.to_s
+    @file = "rubyXL-#{$$}-#{DateTime.now.strftime('%Q')}.xlsx"
+    @workbook.write(@file)
+  end
+
+  describe '.parse' do
+    it 'should parse a valid Excel xlsx or xlsm workbook correctly' do
+      @workbook2 = RubyXL::Parser.parse(@file)
+
+      expect(@workbook2).to be_an_instance_of(::RubyXL::Workbook)
+
+      expect(@workbook2.worksheets.size).to eq(@workbook.worksheets.size)
+      @workbook2.worksheets.each_index { |i|
+        expect(@workbook2[i]).to be_an_instance_of(::RubyXL::Worksheet)
+      }
+    end
+
+    it 'should cause an error if an xlsx or xlsm workbook is not passed' do
+      expect {@workbook2 = RubyXL::Parser.parse("nonexistent_file.tmp")}.to raise_error(Zip::Error)
+    end
+
+    it 'should construct consistent number formats' do
+      @workbook2 = RubyXL::Parser.parse(@file)
+      expect(@workbook2.stylesheet.number_formats).to be_instance_of(RubyXL::NumberFormats)
+      expect(@workbook2.stylesheet.number_formats.size).to eq(1)
+    end
+
+    it 'should unescape HTML entities properly' do
+      @workbook2 = RubyXL::Parser.parse(@file)
+      expect(@workbook2["Escape Test"][0][0].value).to eq("&")
+      expect(@workbook2["Escape Test"][0][1].value).to eq("<")
+      expect(@workbook2["Escape Test"][0][2].value).to eq(">")
+
+      expect(@workbook2["Escape Test"][1][0].value).to eq("&")
+      expect(@workbook2["Escape Test"][1][1].value).to eq("<")
+      expect(@workbook2["Escape Test"][1][2].value).to eq(">")
+    end
+
+    it 'should parse Core properties correctly' do
+      @workbook2 = RubyXL::Parser.parse(@file)
+      expect(@workbook2.creator).to eq("test creator")
+      expect(@workbook2.modifier).to eq("test modifier")
+      expect(@workbook2.created_at).to eq(@time)
+      expect(@workbook2.modified_at).to eq(@time2)
+    end
+
+    it 'should trim excessively long sheet names on save' do
+      @workbook2 = RubyXL::Parser.parse(@file)
+      expect(@workbook2[@test_sheet_name]).to be_nil
+      expect(@workbook2[@test_sheet_name[0..30]]).not_to be_nil
+    end
+
+  end
+
+  describe 'parse_buffer' do
+
+    it 'should parse string buffer correctly' do
+      buffer = File.read(@file)
+      expect(buffer).to be_instance_of(String)
+      f = RubyXL::Parser.parse_buffer(buffer)
+      expect(f).to be_instance_of(RubyXL::Workbook)
+    end
+
+    it 'should parse an IO object correctly' do
+      io = File.open(@file)
+      expect(io).to be_instance_of(File)
+      f = RubyXL::Parser.parse_buffer(io)
+      expect(f).to be_instance_of(RubyXL::Workbook)
+    end
+
+  end
+
+  after do
+    File.delete(@file) if File.exist?(@file)
+  end
+end

data/spec/lib/reference_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe RubyXL::Reference do
+
+  describe '.ind2ref + .ref2ind' do
+    it 'should correctly return the "Excel Style" description of cells when given a row/column number' do
+      expect(RubyXL::Reference.ind2ref(0, 26)).to eq('AA1')
+      expect(RubyXL::Reference.ind2ref(99, 0)).to eq('A100')
+      expect(RubyXL::Reference.ind2ref(0, 26)).to eq('AA1')
+      expect(RubyXL::Reference.ind2ref(0, 51)).to eq('AZ1')
+      expect(RubyXL::Reference.ind2ref(0, 52)).to eq('BA1')
+      expect(RubyXL::Reference.ind2ref(0, 77)).to eq('BZ1')
+      expect(RubyXL::Reference.ind2ref(0, 78)).to eq('CA1')
+      expect(RubyXL::Reference.ind2ref(0, 16383)).to eq('XFD1')
+    end
+
+    it 'should correctly convert back and forth between "Excel Style" and index style cell references' do
+      0.upto(16383) do |n|
+        expect(RubyXL::Reference.ref2ind(RubyXL::Reference.ind2ref(n, 16383 - n))).to eq([ n, 16383 - n ])
+      end
+    end
+
+    it 'should return [-1, -1] if the Excel index is not well-formed' do
+      expect(RubyXL::Reference.ref2ind('A1B')).to eq([-1, -1])
+    end
+  end
+
+end

data/spec/lib/stylesheet_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe RubyXL::NumberFormat do
+
+  describe '.is_date_format?' do
+    it 'should return true if number format = dd// yy// mm' do
+      expect(RubyXL::NumberFormat.new(:num_fmt_id => 1, :format_code => 'dd// yy// mm').is_date_format?()).to eq(true)
+    end  
+
+    it 'should return true if number format = DD// YY// MM (uppercase)' do
+      expect(RubyXL::NumberFormat.new(:num_fmt_id => 1, :format_code => 'DD// YY// MM').is_date_format?()).to eq(true)
+    end  
+
+    it 'should return false if number format = @' do
+      expect(RubyXL::NumberFormat.new(:num_fmt_id => 1, :format_code => '@').is_date_format?()).to eq(false)
+      expect(RubyXL::NumberFormat.new(:num_fmt_id => 1, :format_code => 'general').is_date_format?()).to eq(false)
+      expect(RubyXL::NumberFormat.new(:num_fmt_id => 1, :format_code => '0.00e+00').is_date_format?()).to eq(false)
+    end  
+
+    it 'should properly detect date formats amongst default ones' do
+      all_formats = RubyXL::NumberFormats::DEFAULT_NUMBER_FORMATS
+      id_list = all_formats.collect { |fmt| fmt.num_fmt_id if fmt.is_date_format? }.compact.sort
+      expect(id_list).to eq([14, 15, 16, 17, 18, 19, 20, 21, 22, 45, 46, 47])
+    end
+
+  end
+
+end

data/spec/lib/text_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe RubyXL::Text do
+
+  describe '.to_s' do
+
+    it 'should not crash processing UNICODE data' do
+      bytes = [ 114, 39, 95, 120, 48, 48, 56, 48, 95, 226, 132, 162, 115,
+                32, 103, 105, 114, 108, 102, 114, 105, 101, 110, 100,
+                39, 95, 120, 48, 48, 56, 48, 95, 226, 132, 162, 115, 32, 104, 111]
+
+      t = RubyXL::Text.new(:value => bytes.pack("c*").force_encoding('UTF-8'))
+
+      str = t.to_s
+
+      expect(str).to be
+    end
+
+    it 'should not escape valid XML extended UNICODE characters' do
+      t = RubyXL::Text.new(:value => "\u{10000}\u{10FFFF}")
+
+      xml = t.write_xml[/<t>[^<]+<\/t>/]
+
+      expect(xml).to eq("<t>\u{10000}\u{10FFFF}</t>")
+    end
+
+  end
+
+end

data/spec/lib/workbook_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe RubyXL::Workbook do
+  before do
+    @workbook  = RubyXL::Workbook.new
+    @worksheet = @workbook.add_worksheet('Test Worksheet')
+
+    (0..10).each do |i|
+      (0..10).each do |j|
+        @worksheet.add_cell(i, j, "#{i}:#{j}")
+      end
+    end
+
+    @cell = @worksheet[0][0]
+  end
+
+  describe '.new' do
+    it 'should automatically create a blank worksheet named "Sheet1"' do
+      expect(@workbook[0]).not_to be_nil
+      expect(@workbook[0].sheet_name).to eq('Sheet1')
+    end
+  end
+
+  describe '[]' do
+    it 'should properly locate worksheet by index' do
+      expect(@workbook[1]).not_to be_nil
+      expect(@workbook[1].sheet_name).to eq('Test Worksheet')
+    end
+
+    it 'should properly locate worksheet by name' do
+      expect(@workbook['Test Worksheet']).not_to be_nil
+      expect(@workbook['Test Worksheet'].sheet_name).to eq('Test Worksheet')
+    end
+  end
+
+  describe '.add_worksheet' do
+    it 'when not given a name, it should automatically pick a name "SheetX" that is not taken yet' do
+      expect(@workbook['Sheet2']).to be_nil
+      @workbook.add_worksheet
+      expect(@workbook['Sheet2']).not_to be_nil
+      expect(@workbook['Sheet2'].sheet_name).to eq('Sheet2')
+    end
+  end
+
+  describe '.get_fill_color' do
+    it 'should return the fill color of a particular style attribute' do
+      @cell.change_fill('000000')
+      expect(@workbook.get_fill_color(@workbook.cell_xfs[@cell.style_index])).to eq('000000')
+    end
+
+    it 'should return white (ffffff) if no fill color is specified in style' do
+      expect(@workbook.get_fill_color(@workbook.cell_xfs[@cell.style_index])).to eq('ffffff')
+    end
+  end
+
+  describe '.application' do
+    it 'should contain default application string' do
+      expect(@workbook.application).to eq(RubyXL::Workbook::APPLICATION)
+    end
+
+    it 'should set application properly' do
+      @workbook.application = 'TEST APPLICATION'
+      expect(@workbook.application).to eq('TEST APPLICATION')
+    end
+  end
+
+  describe '.company' do
+    it 'should have default company empty' do
+      expect(@workbook.company).to eq('')
+    end
+
+    it 'should set company properly' do
+      @workbook.company = 'TEST COMPANY'
+      expect(@workbook.company).to eq('TEST COMPANY')
+    end
+  end
+
+  describe '.appversion' do
+    it 'should contain default appversion' do
+      expect(@workbook.appversion).to eq(RubyXL::Workbook::APPVERSION)
+    end
+
+    it 'should set appversion properly' do
+      @workbook.appversion = '12.34'
+      expect(@workbook.appversion).to eq('12.34')
+    end
+  end
+
+  describe '.creator' do
+    it 'should contain default creator' do
+      expect(@workbook.creator).to be_nil
+    end
+
+    it 'should set creator properly' do
+      @workbook.creator = 'CREATOR'
+      expect(@workbook.creator).to eq('CREATOR')
+    end
+  end
+
+  describe '.modifier' do
+    it 'should contain default modifier' do
+      expect(@workbook.modifier).to be_nil
+    end
+
+    it 'should set modifier properly' do
+      @workbook.modifier = 'MODIFIER'
+      expect(@workbook.modifier).to eq('MODIFIER')
+    end
+  end
+
+  describe '.created_at' do
+    it 'should contain current time by default' do
+      expect(@workbook.created_at).to be_a_kind_of(Time)
+    end
+
+    it 'should set modifier properly' do
+      dt = Time.at(Time.now.to_i) # Strip time of microseconds
+      @workbook.created_at = dt
+      expect(@workbook.created_at.to_time).to eq(dt)
+    end
+  end
+
+  describe '.created_at' do
+    it 'should contain current time by default' do
+      expect(@workbook.modified_at).to be_a_kind_of(Time)
+    end
+
+    it 'should set modifier properly' do
+      dt = Time.at(Time.now.to_i) # Strip time of microseconds
+      @workbook.modified_at = dt
+      expect(@workbook.modified_at.to_time).to eq(dt)
+    end
+  end
+
+  describe '.stream' do
+    it "It should not be confused by missing sheet_id" do
+      workbook = RubyXL::Workbook.new
+      workbook[0].sheet_id = 1
+      workbook.add_worksheet('Sheet2')
+      workbook.stream
+    end
+
+    it 'should raise error if bad characters are present in worksheet name' do
+      workbook = RubyXL::Workbook.new
+      workbook[0].sheet_name = 'Sheet007'
+      expect{workbook.stream}.to_not raise_error
+
+      '\\/*[]:?'.each_char { |char|
+        workbook = RubyXL::Workbook.new
+        workbook[0].sheet_name = "Sheet#{char}007"
+        expect{workbook.stream}.to raise_error(RuntimeError)
+      }
+    end
+  end
+
+  describe '.collect_related_objects' do
+    it 'should not save shared strings if there are none' do
+      wb = RubyXL::Workbook.new
+      expect(wb.root.collect_related_objects.map{ |x| x.class }.include?(::RubyXL::SharedStringsTable)).to be false
+      Zip::File.open_buffer(wb.stream) { |zf|
+        expect(zf.entries.any? { |e| e.name =~ /sharedstrings/i }).to be false
+      }
+
+      wb.shared_strings_container.add('test')
+      expect(wb.root.collect_related_objects.map{ |x| x.class }.include?(::RubyXL::SharedStringsTable)).to be true
+      Zip::File.open_buffer(wb.stream) { |zf|
+        expect(zf.entries.any? { |e| e.name =~ /sharedstrings/i }).to be true
+      }
+    end
+  end
+
+
+
+end

data/spec/lib/worksheet_spec.rb

@@ -0,0 +1,1363 @@
+require 'spec_helper'
+
+describe RubyXL::Worksheet do
+  before do
+    @workbook  = RubyXL::Workbook.new
+    @worksheet = @workbook.add_worksheet
+
+    (0..10).each do |i|
+      (0..10).each do |j|
+        @worksheet.add_cell(i, j, "#{i}:#{j}", "F#{i}:#{j}")
+      end
+    end
+
+    @old_cell = @worksheet[0][0]
+    @old_cell_value = @worksheet[0][0].value.to_s
+    @old_cell_formula = @worksheet[0][0].formula.expression.to_s
+  end
+
+  describe '.change_row_fill' do
+    it 'should raise error if hex color code not passed' do
+      expect {
+        @worksheet.change_row_fill(0, 'G')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should raise error if hex color code includes # character' do
+      expect {
+        @worksheet.change_row_fill(3, '#FFF000')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should make row and cell fill colors equal hex color code passed' do
+      @worksheet.change_row_fill(0, '111111')
+      expect(@worksheet.get_row_fill(0)).to eq('111111')
+      expect(@worksheet[0][5].fill_color).to eq('111111')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_row_fill(-1, '111111')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should create a new row if it did not exist before' do
+      expect(@worksheet.sheet_data[11]).to be_nil
+      @worksheet.change_row_fill(11, '111111')
+      expect(@worksheet.sheet_data[11]).to be_a(RubyXL::Row)
+      expect(@worksheet.get_row_fill(11)).to eq('111111')
+    end
+  end
+
+  describe '.change_row_font_name' do
+    it 'should make row and cell font names equal font name passed' do
+      @worksheet.change_row_font_name(0, 'Arial')
+      expect(@worksheet.get_row_font_name(0)).to eq('Arial')
+      expect(@worksheet[0][5].font_name).to eq('Arial')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_row_font_name(-1, 'Arial')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should create a new row if it did not exist before' do
+      expect(@worksheet.sheet_data[11]).to be_nil
+      @worksheet.change_row_font_name(11, 'Arial')
+      expect(@worksheet.sheet_data[11]).to be_a(RubyXL::Row)
+      expect(@worksheet.get_row_font_name(11)).to eq("Arial")
+    end
+  end
+
+  describe '.change_row_font_size' do
+    it 'should make row and cell font sizes equal font number passed' do
+      @worksheet.change_row_font_size(0, 20)
+      expect(@worksheet.get_row_font_size(0)).to eq(20)
+      expect(@worksheet[0][5].font_size).to eq(20)
+    end
+
+    it 'should cause an error if a string passed' do
+      expect {
+        @worksheet.change_row_font_size(0, '20')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_row_font_size(-1,20)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should create a new row if it did not exist before' do
+      expect(@worksheet.sheet_data[11]).to be_nil
+      @worksheet.change_row_font_size(11,20)
+      expect(@worksheet.sheet_data[11]).to be_a(RubyXL::Row)
+      expect(@worksheet.get_row_font_size(11)).to eq(20)
+    end
+  end
+
+  describe '.change_row_font_color' do
+    it 'should make row and cell font colors equal to font color passed' do
+      @worksheet.change_row_font_color(0, '0f0f0f')
+      expect(@worksheet.get_row_font_color(0)).to eq('0f0f0f')
+      expect(@worksheet[0][5].font_color).to eq('0f0f0f')
+    end
+
+    it 'should raise error if hex color code not passed' do
+      expect {
+        @worksheet.change_row_font_color(0, 'G')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should raise error if hex color code includes # character' do
+      expect {
+        @worksheet.change_row_font_color(3, '#FFF000')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_row_font_color(-1, '0f0f0f')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should create a new row if it did not exist before' do
+      expect(@worksheet.sheet_data[11]).to be_nil
+      @worksheet.change_row_font_color(11, '0f0f0f')
+      expect(@worksheet.sheet_data[11]).to be_a(RubyXL::Row)
+      expect(@worksheet.get_row_font_color(11)).to eq('0f0f0f')
+    end
+  end
+
+  describe '.change_row_italics' do
+    it 'should make row and cell fonts italicized when true is passed' do
+      @worksheet.change_row_italics(0, true)
+      expect(@worksheet.is_row_italicized(0)).to eq(true)
+      expect(@worksheet[0][5].is_italicized).to eq(true)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_row_italics(-1, false)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should create a new row if it did not exist before' do
+      expect(@worksheet.sheet_data[11]).to be_nil
+      @worksheet.change_row_italics(11,true)
+      expect(@worksheet.sheet_data[11]).to be_a(RubyXL::Row)
+      expect(@worksheet.is_row_italicized(11)).to eq(true)
+    end
+  end
+
+  describe '.change_row_bold' do
+    it 'should make row and cell fonts bolded when true is passed' do
+      @worksheet.change_row_bold(0, true)
+      expect(@worksheet.is_row_bolded(0)).to eq(true)
+      expect(@worksheet[0][5].is_bolded).to eq(true)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_row_bold(-1, false)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should create a new row if it did not exist before' do
+      expect(@worksheet.sheet_data[11]).to be_nil
+      @worksheet.change_row_bold(11, true)
+      expect(@worksheet.sheet_data[11]).to be_a(RubyXL::Row)
+      expect(@worksheet.is_row_bolded(11)).to eq(true)
+    end
+  end
+
+  describe '.change_row_underline' do
+    it 'should make row and cell fonts underlined when true is passed' do
+      @worksheet.change_row_underline(0, true)
+      expect(@worksheet.is_row_underlined(0)).to eq(true)
+      expect(@worksheet[0][5].is_underlined).to eq(true)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_row_underline(-1, false)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should create a new row if it did not exist before' do
+      expect(@worksheet.sheet_data[11]).to be_nil
+      @worksheet.change_row_underline(11,true)
+      expect(@worksheet.sheet_data[11]).to be_a(RubyXL::Row)
+      expect(@worksheet.is_row_underlined(11)).to eq(true)
+    end
+  end
+
+  describe '.change_row_strikethrough' do
+    it 'should make row and cell fonts struckthrough when true is passed' do
+      @worksheet.change_row_strikethrough(0, true)
+      expect(@worksheet.is_row_struckthrough(0)).to eq(true)
+      expect(@worksheet[0][5].is_struckthrough).to eq(true)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_row_strikethrough(-1, false)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should create a new row if it did not exist before' do
+      expect(@worksheet.sheet_data[11]).to be_nil
+      @worksheet.change_row_strikethrough(11,true)
+      expect(@worksheet.sheet_data[11]).to be_a(RubyXL::Row)
+      expect(@worksheet.is_row_struckthrough(11)).to eq(true)
+    end
+  end
+
+  describe '.change_row_height' do
+    it 'should make row height match number which is passed' do
+      @worksheet.change_row_height(0,30.0002)
+      expect(@worksheet.get_row_height(0)).to eq(30.0002)
+    end
+
+    it 'should make row height a number equivalent of the string passed if it is a string which is a number' do
+      @worksheet.change_row_height(0, 30.0002)
+      expect(@worksheet.get_row_height(0)).to eq(30.0002)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_row_height(-1, 30)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should create a new row if it did not exist before' do
+      expect(@worksheet.sheet_data[11]).to be_nil
+      @worksheet.change_row_height(11, 30)
+      expect(@worksheet.sheet_data[11]).to be_a(RubyXL::Row)
+      expect(@worksheet.get_row_height(11)).to eq(30)
+    end
+  end
+
+  describe '.change_row_horizontal_alignment' do
+    it 'should cause row and cells to horizontally align as specified by the passed in string' do
+      @worksheet.change_row_horizontal_alignment(0, 'center')
+      expect(@worksheet.get_row_alignment(0, true)).to eq('center')
+      expect(@worksheet[0][5].horizontal_alignment).to eq('center')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_row_horizontal_alignment(-1, 'center')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should create a new row if it did not exist before' do
+      expect(@worksheet.sheet_data[11]).to be_nil
+      @worksheet.change_row_horizontal_alignment(11, 'center')
+      expect(@worksheet.sheet_data[11]).to be_a(RubyXL::Row)
+      expect(@worksheet.get_row_alignment(11, true)).to eq('center')
+    end
+  end
+
+  describe '.change_row_vertical_alignment' do
+    it 'should cause row and cells to vertically align as specified by the passed in string' do
+      @worksheet.change_row_vertical_alignment(0, 'center')
+      expect(@worksheet.get_row_alignment(0, false)).to eq('center')
+      expect(@worksheet[0][5].vertical_alignment).to eq('center')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_row_vertical_alignment(-1, 'center')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should create a new row if it did not exist before' do
+      expect(@worksheet.sheet_data[11]).to be_nil
+      @worksheet.change_row_vertical_alignment(11, 'center')
+      expect(@worksheet.sheet_data[11]).to be_a(RubyXL::Row)
+      expect(@worksheet.get_row_alignment(11, false)).to eq('center')
+    end
+  end
+
+  describe '.change_row_border' do
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_row_border(-1, :left, 'thin')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should create a new row if it did not exist before' do
+      expect(@worksheet.sheet_data[11]).to be_nil
+      @worksheet.change_row_border(11, :left, 'thin')
+      expect(@worksheet.sheet_data[11]).to be_a(RubyXL::Row)
+      expect(@worksheet.get_row_border(11, :left)).to eq('thin')
+    end
+
+    it 'should cause row and cells to have border at top of specified weight' do
+      @worksheet.change_row_border(0, :top, 'thin')
+      expect(@worksheet.get_row_border(0, :top)).to eq('thin')
+      expect(@worksheet[0][5].get_border(:top)).to eq('thin')
+    end
+
+    it 'should cause row and cells to have border at left of specified weight' do
+      @worksheet.change_row_border(0, :left, 'thin')
+      expect(@worksheet.get_row_border(0, :left)).to eq('thin')
+      expect(@worksheet[0][5].get_border(:left)).to eq('thin')
+    end
+
+    it 'should cause row and cells to have border at right of specified weight' do
+      @worksheet.change_row_border(0, :right, 'thin')
+      expect(@worksheet.get_row_border(0, :right)).to eq('thin')
+      expect(@worksheet[0][5].get_border(:right)).to eq('thin')
+    end
+
+    it 'should cause row to have border at bottom of specified weight' do
+      @worksheet.change_row_border(0, :bottom, 'thin')
+      expect(@worksheet.get_row_border(0, :bottom)).to eq('thin')
+      expect(@worksheet[0][5].get_border(:bottom)).to eq('thin')
+    end
+
+    it 'should cause row to have border at diagonal of specified weight' do
+      @worksheet.change_row_border(0, :diagonal, 'thin')
+      expect(@worksheet.get_row_border(0, :diagonal)).to eq('thin')
+      expect(@worksheet[0][5].get_border(:diagonal)).to eq('thin')
+    end
+  end
+
+  describe '.change_column_font_name' do
+    it 'should cause column and cell font names to match string passed in' do
+      @worksheet.change_column_font_name(0, 'Arial')
+      expect(@worksheet.get_column_font_name(0)).to eq('Arial')
+      expect(@worksheet[5][0].font_name).to eq('Arial')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_column_font_name(-1, 'Arial')
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.change_column_font_size' do
+    it 'should make column and cell font sizes equal font number passed' do
+      @worksheet.change_column_font_size(0, 20)
+      expect(@worksheet.get_column_font_size(0)).to eq(20)
+      expect(@worksheet[5][0].font_size).to eq(20)
+    end
+
+    it 'should cause an error if a string passed' do
+      expect {
+        @worksheet.change_column_font_size(0, '20')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_column_font_size(-1, 20)
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.change_column_font_color' do
+    it 'should make column and cell font colors equal to font color passed' do
+      @worksheet.change_column_font_color(0, '0f0f0f')
+      expect(@worksheet.get_column_font_color(0)).to eq('0f0f0f')
+      expect(@worksheet[5][0].font_color).to eq('0f0f0f')
+    end
+
+    it 'should raise error if hex color code not passed' do
+      expect {
+        @worksheet.change_column_font_color(0, 'G')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should raise error if hex color code includes # character' do
+      expect {
+        @worksheet.change_column_font_color(0, '#FFF000')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_column_font_color(-1, '0f0f0f')
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.change_column_italics' do
+    it 'should make column and cell fonts italicized when true is passed' do
+      @worksheet.change_column_italics(0, true)
+      expect(@worksheet.is_column_italicized(0)).to eq(true)
+      expect(@worksheet[5][0].is_italicized).to eq(true)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_column_italics(-1, false)
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.change_column_bold' do
+    it 'should make column and cell fonts bolded when true is passed' do
+      @worksheet.change_column_bold(0, true)
+      expect(@worksheet.is_column_bolded(0)).to eq(true)
+      expect(@worksheet[5][0].is_bolded).to eq(true)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_column_bold(-1, false)
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.change_column_underline' do
+    it 'should make column and cell fonts underlined when true is passed' do
+      @worksheet.change_column_underline(0, true)
+      expect(@worksheet.is_column_underlined(0)).to eq(true)
+      expect(@worksheet[5][0].is_underlined).to eq(true)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_column_underline(-1, false)
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.change_column_strikethrough' do
+    it 'should make column and cell fonts struckthrough when true is passed' do
+      @worksheet.change_column_strikethrough(0, true)
+      expect(@worksheet.is_column_struckthrough(0)).to eq(true)
+      expect(@worksheet[5][0].is_struckthrough).to eq(true)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_column_strikethrough(-1, false)
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.change_column_width_raw' do
+    it 'should make column width match number which is passed' do
+      @worksheet.change_column_width_raw(0, 30.0002)
+      expect(@worksheet.get_column_width_raw(0)).to eq(30.0002)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_column_width_raw(-1, 10)
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.change_column_fill' do
+    it 'should raise error if hex color code not passed' do
+      expect {
+        @worksheet.change_column_fill(0, 'G')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should raise error if hex color code includes # character' do
+      expect {
+        @worksheet.change_column_fill(3, '#FFF000')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should make column and cell fill colors equal hex color code passed' do
+      @worksheet.change_column_fill(0, '111111')
+      expect(@worksheet.get_column_fill(0)).to eq('111111')
+      expect(@worksheet[5][0].fill_color).to eq('111111')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_column_fill(-1, '111111')
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.change_column_horizontal_alignment' do
+    it 'should cause column and cell to horizontally align as specified by the passed in string' do
+      @worksheet.change_column_horizontal_alignment(0, 'center')
+      expect(@worksheet.get_column_alignment(0, :horizontal)).to eq('center')
+      expect(@worksheet[5][0].horizontal_alignment).to eq('center')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_column_horizontal_alignment(-1, 'center')
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.change_column_vertical_alignment' do
+    it 'should cause column and cell to vertically align as specified by the passed in string' do
+      @worksheet.change_column_vertical_alignment(0, 'center')
+      expect(@worksheet.get_column_alignment(0, :vertical)).to eq('center')
+      expect(@worksheet[5][0].vertical_alignment).to eq('center')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_column_vertical_alignment(-1, 'center')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should set column width if column alignment is changed' do
+      test_column = 2
+      expect(@worksheet.get_column_alignment(test_column, :vertical)).to be_nil
+      expect(@worksheet.get_column_width_raw(test_column)).to be_nil
+      expect(@worksheet.get_column_width(test_column)).to eq(RubyXL::ColumnRange::DEFAULT_WIDTH)
+      @worksheet.change_column_vertical_alignment(test_column, 'top')
+      expect(@worksheet.get_column_width_raw(test_column)).not_to be_nil
+      expect(@worksheet.get_column_width(test_column)).to eq(RubyXL::ColumnRange::DEFAULT_WIDTH)
+      expect(@worksheet.get_column_alignment(test_column, :vertical)).to eq('top')
+    end
+  end
+
+  describe '.change_column_border' do
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.change_column_border(-1, :top, 'thin')
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should cause column and cells within to have border at top of specified weight' do
+      @worksheet.change_column_border(0, :top, 'thin')
+      expect(@worksheet.get_column_border(0, :top)).to eq('thin')
+      expect(@worksheet[5][0].get_border(:top)).to eq('thin')
+    end
+
+    it 'should cause column and cells within to have border at left of specified weight' do
+      @worksheet.change_column_border(0, :left, 'thin')
+      expect(@worksheet.get_column_border(0, :left)).to eq('thin')
+      expect(@worksheet[5][0].get_border(:left)).to eq('thin')
+    end
+
+    it 'should cause column and cells within to have border at right of specified weight' do
+      @worksheet.change_column_border(0, :right, 'thin')
+      expect(@worksheet.get_column_border(0, :right)).to eq('thin')
+      expect(@worksheet[5][0].get_border(:right)).to eq('thin')
+    end
+
+    it 'should cause column and cells within to have border at bottom of specified weight' do
+      @worksheet.change_column_border(0, :bottom, 'thin')
+      expect(@worksheet.get_column_border(0, :bottom)).to eq('thin')
+      expect(@worksheet[5][0].get_border(:bottom)).to eq('thin')
+    end
+
+    it 'should cause column and cells within to have border at diagonal of specified weight' do
+      @worksheet.change_column_border(0, :diagonal, 'thin')
+      expect(@worksheet.get_column_border(0, :diagonal)).to eq('thin')
+      expect(@worksheet[5][0].get_border(:diagonal)).to eq('thin')
+    end
+  end
+
+  describe '.merge_cells' do
+    it 'should merge cells in any valid range specified by indices' do
+      @worksheet.merge_cells(0, 0, 1, 1)
+      expect(@worksheet.merged_cells.collect{ |r| r.ref.to_s }).to eq(["A1:B2"])
+    end
+  end
+
+  describe '.add_cell' do
+    it 'should add new cell where specified, even if a cell is already there (default)' do
+      @worksheet.add_cell(0,0, 'TEST')
+      expect(@worksheet[0][0].value).not_to eq(@old_cell_value)
+      expect(@worksheet[0][0].value).to eq('TEST')
+    end
+
+    it 'should add a new cell below nil rows that might exist' do
+      @worksheet.sheet_data.rows << nil << nil
+      @worksheet.add_cell(15,0, 'TEST')
+      expect(@worksheet[15][0].value).to eq('TEST')
+    end
+
+    it 'should add new cell where specified with formula, even if a cell is already there (default)' do
+      @worksheet.add_cell(0,0, '', 'SUM(A2:A10)')
+      expect(@worksheet[0][0].value).not_to eq(@old_cell_value)
+      expect(@worksheet[0][0].formula).not_to eq(@old_cell_formula)
+      expect(@worksheet[0][0].value).to eq('')
+      expect(@worksheet[0][0].formula.expression).to eq('SUM(A2:A10)')
+    end
+
+    it 'should not overwrite when a cell is present when overwrite is specified to be false' do
+      @worksheet.add_cell(0,0, 'TEST', 'B2',false)
+      expect(@worksheet[0][0].value).to eq(@old_cell_value)
+      expect(@worksheet[0][0].formula.expression.to_s).to eq(@old_cell_formula)
+    end
+
+    it 'should still add a new cell when there is no cell to be overwritten' do
+      @worksheet.add_cell(11,11, 'TEST', 'B2',false)
+      expect(@worksheet[11][11].value).to eq('TEST')
+      expect(@worksheet[11][11].formula.expression).to eq('B2')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.add_cell(-1,-1, '')
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.delete_row' do
+    it 'should delete a row at index specified, "pushing" everything else "up"' do
+      @worksheet.delete_row(0)
+      expect(@worksheet[0][0].value).to eq("1:0")
+      expect(@worksheet[0][0].formula.expression.to_s).to eq("F1:0")
+      expect(@worksheet[0][0].row).to eq(0)
+      expect(@worksheet[0][0].column).to eq(0)
+    end
+
+    it 'should delete a row at index specified, adjusting styles for other rows' do
+      @worksheet.change_row_font_name(1,"Courier")
+      @worksheet.delete_row(0)
+      expect(@worksheet.get_row_font_name(0)).to eq("Courier")
+    end
+
+    it 'should preserve (rather than fix) formulas that reference cells in "pushed up" rows' do
+      @worksheet.add_cell(11, 0, nil, 'SUM(A1:A10)')
+      @worksheet.delete_row(0)
+      expect(@worksheet[10][0].formula.expression).to eq('SUM(A1:A10)')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.delete_row(-1)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should properly reindex the cells'  do
+      @worksheet.sheet_data.rows.each_with_index { |row, r|
+        row.cells.each_with_index { |cell, c|
+          expect(cell.row).to eq(r)
+          expect(cell.column).to eq(c)
+        }
+      }
+    end
+  end
+
+  describe '.insert_row' do
+    it 'should insert a row at index specified, "pushing" everything else "down"' do
+      @worksheet.insert_row(0)
+      expect(@worksheet[0][0]).to be_nil
+      expect(@worksheet[1][0].value).to eq(@old_cell_value)
+      expect(@worksheet[1][0].formula.expression.to_s).to eq(@old_cell_formula)
+
+      @worksheet.insert_row(5)
+      expect(@worksheet[5][0].is_underlined).to be_nil
+    end
+
+    it 'should insert a row skipping nil rows that might exist' do
+      @worksheet.sheet_data.rows << nil << nil
+      rows = @worksheet.sheet_data.rows.size
+      @worksheet.insert_row(rows)
+      expect(@worksheet[rows - 1]).to be_nil
+    end
+
+    it 'should insert a row at index specified, copying styles from row "above"' do
+      @worksheet.change_row_font_name(0, 'Courier')
+      @worksheet.insert_row(1)
+      expect(@worksheet.get_row_font_name(1)).to eq('Courier')
+    end
+
+    it 'should preserve (rather than fix) formulas that reference cells "pushed down" rows' do
+      @worksheet.add_cell(5,0,nil, 'SUM(A1:A4)')
+      @worksheet.insert_row(0)
+      expect(@worksheet[6][0].formula.expression).to eq('SUM(A1:A4)')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.insert_row(-1)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should expand matrix to fit argument if nonnegative'  do
+      expect(@worksheet.sheet_data.size).to eq(11)
+      @worksheet.insert_row(11)
+      expect(@worksheet.sheet_data.size).to eq(13)
+    end
+
+    it 'should properly reindex the cells'  do
+      @worksheet.sheet_data.rows.each_with_index { |row, r|
+        row.cells.each_with_index { |cell, c|
+          expect(cell.row).to eq(r)
+          expect(cell.column).to eq(c)
+        }
+      }
+    end
+  end
+
+  describe '.delete_column' do
+    it 'should delete a column at index specified, "pushing" everything else "left"' do
+      @worksheet.delete_column(0)
+      expect(@worksheet[0][0].value).to eq("0:1")
+      expect(@worksheet[0][0].formula.expression.to_s).to eq("F0:1")
+      expect(@worksheet[0][0].row).to eq(0)
+    end
+
+    it 'should delete a column at index specified, "pushing" styles "left"' do
+      @worksheet.change_column_font_name(1,"Courier")
+      @worksheet.delete_column(0)
+      expect(@worksheet.get_column_font_name(0)).to eq("Courier")
+    end
+
+    it 'should preserve (rather than fix) formulas that reference cells in "pushed left" columns' do
+      @worksheet.add_cell(0,4,nil, 'SUM(A1:D1)')
+      @worksheet.delete_column(0)
+      expect(@worksheet[0][3].formula.expression).to eq('SUM(A1:D1)')
+    end
+
+    it 'should update cell indices after deleting the column' do
+      @worksheet.delete_column(2)
+      @worksheet[0].cells.each_with_index { |cell, i|
+        expect(cell.column).to eq(i)
+      }
+    end
+
+    it 'should cause error if negative argument is passed in' do
+      expect {
+        @worksheet.delete_column(-1)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should properly reindex the cells'  do
+      @worksheet.sheet_data.rows.each_with_index { |row, r|
+        row.cells.each_with_index { |cell, c|
+          expect(cell.row).to eq(r)
+          expect(cell.column).to eq(c)
+        }
+      }
+    end
+  end
+
+  describe '.insert_column' do
+    it 'should insert a column at index specified, "pushing" everything else "right"' do
+      @worksheet.insert_column(0)
+      expect(@worksheet[0][0]).to be_nil
+      expect(@worksheet[0][1].value).to eq(@old_cell_value)
+      expect(@worksheet[0][1].formula.expression.to_s).to eq(@old_cell_formula)
+    end
+
+    it 'should insert a column at index specified, copying styles from column to "left"' do
+      @worksheet.change_column_font_name(0, 'Courier')
+      @worksheet.insert_column(1)
+      expect(@worksheet.get_column_font_name(1)).to eq('Courier')
+    end
+
+    it 'should insert a column at 0 without copying any styles, when passed 0 as column index' do
+      @worksheet.change_column_font_name(0, 'Courier')
+      @worksheet.insert_column(0)
+      expect(@worksheet.get_column_font_name(0)).to eq('Verdana') #not courier
+    end
+
+    it 'should preserve (rather than fix) formulas that reference cells in "pushed right" column' do
+      @worksheet.add_cell(0,5,nil, 'SUM(A1:D1)')
+      @worksheet.insert_column(0)
+      expect(@worksheet[0][6].formula.expression).to eq('SUM(A1:D1)')
+    end
+
+    it 'should update cell indices after deleting the column' do
+      @worksheet.insert_column(5)
+      @worksheet[0].cells.each_with_index { |cell, i| 
+        next if cell.nil?
+        expect(cell.column).to eq(i)
+      }
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.insert_column(-1)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should properly reindex the cells'  do
+      @worksheet.sheet_data.rows.each_with_index { |row, r|
+        row.cells.each_with_index { |cell, c|
+          expect(cell.row).to eq(r)
+          expect(cell.column).to eq(c)
+        }
+      }
+    end
+  end
+
+  describe '.insert_cell' do
+    it 'should simply add a cell if no shift argument is specified' do
+      @worksheet.insert_cell(0,0, 'test')
+      expect(@worksheet[0][0].value).to eq('test')
+      expect(@worksheet[0][1].value).to eq('0:1')
+      expect(@worksheet[1][0].value).to eq('1:0')
+    end
+
+    it 'should shift cells to the right if :right is specified' do
+      @worksheet.insert_cell(0, 0, 'test', nil, :right)
+      expect(@worksheet[0][0].value).to eq('test')
+      expect(@worksheet[0][1].value).to eq('0:0')
+      expect(@worksheet[1][0].value).to eq('1:0')
+    end
+
+    it 'should update cell indices after inserting the cell' do
+      @worksheet.insert_cell(0, 0, 'test', nil, :right)
+      @worksheet[0].cells.each_with_index { |cell, i|
+        expect(cell.column).to eq(i)
+      }
+    end
+
+    it 'should shift cells down if :down is specified' do
+      @worksheet.insert_cell(0, 0, 'test', nil, :down)
+      expect(@worksheet[0][0].value).to eq('test')
+      expect(@worksheet[0][1].value).to eq('0:1')
+      expect(@worksheet[1][0].value).to eq('0:0')
+    end
+
+    it 'should cause error if shift argument is specified whcih is not :right or :down' do
+      expect {
+        @worksheet.insert_cell(0, 0, 'test', nil, :up)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.insert_cell(-1, -1)
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.delete_cell' do
+    it 'should make a cell nil if no shift argument specified' do
+      deleted = @worksheet.delete_cell(0, 0)
+      expect(@worksheet[0][0]).to be_nil
+      expect(@old_cell.inspect).to eq(deleted.inspect)
+    end
+
+    it 'should return nil if a cell which is out of range is specified' do
+      expect(@worksheet.delete_cell(12, 12)).to be_nil
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.delete_cell(-1,-1)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should shift cells to the right of the deleted cell left if :left is specified' do
+      @worksheet.delete_cell(0, 0, :left)
+      expect(@worksheet[0][0].value).to eq('0:1')
+    end
+
+    it 'should update cell indices after deleting the cell' do
+      @worksheet.delete_cell(4, 0, :left)
+      @worksheet[0].cells.each_with_index { |cell, i|
+        expect(cell.column).to eq(i)
+      }
+    end
+
+    it 'should shift cells below the deleted cell up if :up is specified' do
+      @worksheet.delete_cell(0,0,:up)
+      expect(@worksheet[0][0].value).to eq('1:0')
+    end
+
+    it 'should cause en error if an argument other than :left, :up, or nil is specified for shift' do
+      expect {
+        @worksheet.delete_cell(0,0,:down)
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.get_row_fill' do
+    it 'should return white (ffffff) if no fill color specified for row' do
+      expect(@worksheet.get_row_fill(0)).to eq('ffffff')
+    end
+
+    it 'should correctly reflect fill color if specified for row' do
+      @worksheet.change_row_fill(0, '000000')
+      expect(@worksheet.get_row_fill(0)).to eq('000000')
+    end
+
+    it 'should return nil if a row which does not exist is passed in' do
+      expect(@worksheet.get_row_fill(11)).to be_nil
+    end
+  end
+
+  describe '.get_row_font_name' do
+    it 'should correctly reflect font name for row' do
+      @worksheet.change_row_font_name(0, 'Courier')
+      expect(@worksheet.get_row_font_name(0)).to eq('Courier')
+    end
+
+    it 'should return nil if a (nonnegative) row which does not exist is passed in' do
+      expect(@worksheet.get_row_font_name(11)).to be_nil
+    end
+  end
+
+  describe '.get_row_font_size' do
+    it 'should correctly reflect font size for row' do
+      @worksheet.change_row_font_size(0,30)
+      expect(@worksheet.get_row_font_size(0)).to eq(30)
+    end
+
+    it 'should return nil if a (nonnegative) row which does not exist is passed in' do
+      expect(@worksheet.get_row_font_size(11)).to be_nil
+    end
+  end
+
+  describe '.get_row_font_color' do
+    it 'should correctly reflect font color for row' do
+      @worksheet.change_row_font_color(0, '0f0f0f')
+      expect(@worksheet.get_row_font_color(0)).to eq('0f0f0f')
+    end
+
+    it 'should return nil if a (nonnegative) row which does not exist is passed in' do
+      expect(@worksheet.get_row_font_color(11)).to be_nil
+    end
+  end
+
+  describe '.is_row_italicized' do
+    it 'should correctly return whether row is italicized' do
+      @worksheet.change_row_italics(0, true)
+      expect(@worksheet.is_row_italicized(0)).to eq(true)
+    end
+
+    it 'should return nil if a (nonnegative) row which does not exist is passed in' do
+      expect(@worksheet.is_row_italicized(11)).to be_nil
+    end
+  end
+
+  describe '.is_row_bolded' do
+    it 'should correctly return whether row is bolded' do
+      @worksheet.change_row_bold(0, true)
+      expect(@worksheet.is_row_bolded(0)).to eq(true)
+    end
+
+    it 'should return nil if a (nonnegative) row which does not exist is passed in' do
+      expect(@worksheet.is_row_bolded(11)).to be_nil
+    end
+  end
+
+  describe '.is_row_underlined' do
+    it 'should correctly return whether row is underlined' do
+      @worksheet.change_row_underline(0, true)
+      expect(@worksheet.is_row_underlined(0)).to eq(true)
+    end
+
+    it 'should return nil if a (nonnegative) row which does not exist is passed in' do
+      expect(@worksheet.is_row_underlined(11)).to be_nil
+    end
+  end
+
+  describe '.is_row_struckthrough' do
+    it 'should correctly return whether row is struckthrough' do
+      @worksheet.change_row_strikethrough(0, true)
+      expect(@worksheet.is_row_struckthrough(0)).to eq(true)
+    end
+
+    it 'should return nil if a (nonnegative) row which does not exist is passed in' do
+      expect(@worksheet.is_row_struckthrough(11)).to be_nil
+    end
+  end
+
+  describe '.get_row_height' do
+    it 'should return 13 if no height specified for row' do
+      expect(@worksheet.get_row_height(0)).to eq(13)
+    end
+
+    it 'should correctly reflect height if specified for row' do
+      @worksheet.change_row_height(0, 30)
+      expect(@worksheet.get_row_height(0)).to eq(30)
+    end
+
+    it 'should return default row height if a row which does not exist is passed in' do
+      expect(@worksheet.get_row_height(11)).to eq(13)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.get_row_height(-1)
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.get_row_alignment' do
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.get_row_alignment(-1, true)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should return nil if no horizontal alignment specified for row' do
+      expect(@worksheet.get_row_alignment(0, true)).to be_nil
+    end
+
+    it 'should return nil if a row which does not exist is passed in' do
+      expect(@worksheet.get_row_alignment(11, true)).to be_nil
+    end
+
+    it 'should return correct horizontal alignment if it is set for that row' do
+      @worksheet.change_row_horizontal_alignment(0, 'center')
+      expect(@worksheet.get_row_alignment(0, true)).to eq('center')
+    end
+
+    it 'should return nil if no alignment specified for row' do
+      expect(@worksheet.get_row_alignment(0, false)).to be_nil
+    end
+
+    it 'should return nil if a row which does not exist is passed in' do
+      expect(@worksheet.get_row_alignment(11, false)).to be_nil
+    end
+
+    it 'should return correct vertical alignment if it is set for that row' do
+      @worksheet.change_row_vertical_alignment(0, 'center')
+      expect(@worksheet.get_row_alignment(0, false)).to eq('center')
+    end
+  end
+
+  describe '.get_row_border' do
+    it 'should return nil if no border is specified for that row in that direction' do
+      expect(@worksheet.get_row_border(0, :top)).to be_nil
+    end
+
+    it 'should return type of border that this row has on top' do
+      @worksheet.change_row_border(0, :top, 'thin')
+      expect(@worksheet.get_row_border(0, :top)).to eq('thin')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.get_row_border(-1, :top)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should return nil if a row which does not exist is passed in' do
+      expect(@worksheet.get_row_border(11, :top)).to be_nil
+    end
+  end
+
+  describe '.get_column_font_name' do
+    it 'should correctly reflect font name for column' do
+      @worksheet.change_column_font_name(0, 'Courier')
+      expect(@worksheet.get_column_font_name(0)).to eq('Courier')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.get_column_font_name(-1)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should return default font if a (nonnegative) column which does not exist is passed in' do
+      expect(@worksheet.get_column_font_name(11)).to eq('Verdana')
+    end
+  end
+
+  describe '.get_column_font_size' do
+    it 'should correctly reflect font size for column' do
+      @worksheet.change_column_font_size(0,30)
+     expect(@worksheet.get_column_font_size(0)).to eq(30)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.get_column_font_size(-1)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should return default font size if a column which does not exist is passed in' do
+      expect(@worksheet.get_column_font_size(11)).to eq(10)
+    end
+  end
+
+  describe '.get_column_font_color' do
+    it 'should correctly reflect font color for column' do
+      @worksheet.change_column_font_color(0, '0f0f0f')
+     expect(@worksheet.get_column_font_color(0)).to eq('0f0f0f')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.get_column_font_color(-1)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should return default color (000000) if a (nonnegative) column which does not exist is passed in' do
+      expect(@worksheet.get_column_font_color(11)).to eq('000000')
+    end
+
+    it 'should return default color (000000) if no rgb font color is specified' do
+      expect(@worksheet.get_column_font_color(0)).to eq('000000')
+    end
+  end
+
+  describe '.is_column_italicized' do
+    it 'should correctly return whether column is italicized' do
+      @worksheet.change_column_italics(0, true)
+     expect(@worksheet.is_column_italicized(0)).to eq(true)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.is_column_italicized(-1)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should return nil if a (nonnegative) column which does not exist is passed in' do
+      expect(@worksheet.is_column_italicized(11)).to be_nil
+    end
+  end
+
+  describe '.is_column_bolded' do
+    it 'should correctly return whether column is bolded' do
+      @worksheet.change_column_bold(0, true)
+     expect(@worksheet.is_column_bolded(0)).to eq(true)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.is_column_bolded(-1)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should return nil if a (nonnegative) column which does not exist is passed in' do
+      expect(@worksheet.is_column_bolded(11)).to be_nil
+    end
+  end
+
+  describe '.is_column_underlined' do
+    it 'should correctly return whether column is underlined' do
+      @worksheet.change_column_underline(0, true)
+     expect(@worksheet.is_column_underlined(0)).to eq(true)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.is_column_underlined(-1)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should return nil if a (nonnegative) column which does not exist is passed in' do
+      expect(@worksheet.is_column_underlined(11)).to be_nil
+    end
+  end
+
+  describe '.is_column_struckthrough' do
+    it 'should correctly return whether column is struckthrough' do
+      @worksheet.change_column_strikethrough(0, true)
+     expect(@worksheet.is_column_struckthrough(0)).to eq(true)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.is_column_struckthrough(-1)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should return nil if a (nonnegative) column which does not exist is passed in' do
+      expect(@worksheet.is_column_struckthrough(11)).to be_nil
+    end
+  end
+
+  describe '.get_column_width_raw' do
+    it 'should return nil if no width specified for column' do
+      expect(@worksheet.get_column_width_raw(0)).to be_nil
+    end
+
+    it 'should correctly reflect width if specified for column' do
+      @worksheet.change_column_width_raw(0, 30.123)
+      expect(@worksheet.get_column_width_raw(0)).to eq(30.123)
+    end
+
+    it 'should return nil for a column that does not exist' do
+      expect(@worksheet.get_column_width_raw(11)).to be_nil
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.get_column_width_raw(-1)
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.get_column_width' do
+    it 'should return default width if no width specified for column' do
+      expect(@worksheet.get_column_width(0)).to eq(RubyXL::ColumnRange::DEFAULT_WIDTH)
+    end
+
+    it 'should correctly reflect width if specified for column' do
+      @worksheet.change_column_width(0, 15)
+      expect(@worksheet.get_column_width(0)).to eq(15)
+    end
+
+    it 'should return default width for a column that does not exist' do
+      expect(@worksheet.get_column_width(11)).to eq(RubyXL::ColumnRange::DEFAULT_WIDTH)
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.get_column_width(-1)
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.get_column_fill' do
+    it 'should return white (ffffff) if no fill color specified for column' do
+      expect(@worksheet.get_column_fill(0)).to eq('ffffff')
+    end
+
+    it 'should correctly reflect fill color if specified for column' do
+      @worksheet.change_column_fill(0, '000000')
+     expect(@worksheet.get_column_fill(0)).to eq('000000')
+    end
+
+    it 'should return nil if a column which does not exist is passed in' do
+      expect(@worksheet.get_column_fill(11)).to eq('ffffff')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.get_column_fill(-1)
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '.get_column_horizontal_alignment' do
+    it 'should return nil if no alignment specified for column' do
+      expect(@worksheet.get_column_alignment(0, :horizontal)).to be_nil
+    end
+
+    it 'should return nil if a column which does not exist is passed in' do
+      expect(@worksheet.get_column_alignment(11, :horizontal)).to be_nil
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.get_column_alignment(-1, :horizontal)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should return correct horizontal alignment if it is set for that column' do
+      @worksheet.change_column_horizontal_alignment(0, 'center')
+      expect(@worksheet.get_column_alignment(0, :horizontal)).to eq('center')
+    end
+  end
+
+  describe '.get_column_vertical_alignment' do
+    it 'should return nil if no alignment specified for column' do
+      expect(@worksheet.get_column_alignment(0, :vertical)).to be_nil
+    end
+
+    it 'should return nil if a column which does not exist is passed in' do
+      expect(@worksheet.get_column_alignment(11, :vertical)).to be_nil
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.get_column_alignment(-1, :vertical)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should return correct vertical alignment if it is set for that column' do
+      @worksheet.change_column_vertical_alignment(0, 'center')
+      expect(@worksheet.get_column_alignment(0, :vertical)).to eq('center')
+    end
+  end
+
+  describe '.get_column_border' do
+    it 'should return nil if no border is specified for that column in that direction' do
+      expect(@worksheet.get_column_border(0, :diagonal)).to be_nil
+    end
+
+    it 'should return type of border that this column has on diagonal' do
+      @worksheet.change_column_border(0, :diagonal, 'thin')
+      expect(@worksheet.get_column_border(0, :diagonal)).to eq('thin')
+    end
+
+    it 'should cause error if a negative argument is passed in' do
+      expect {
+        @worksheet.get_column_border(-1, :diagonal)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'should return nil if a column which does not exist is passed in' do
+      expect(@worksheet.get_column_border(11, :diagonal)).to be_nil
+    end
+  end
+
+  describe '@column_range' do
+    it 'should properly handle range addition and modification' do
+      # Ranges should be empty for brand new worskeet
+      expect(@worksheet.cols.size).to eq(0)
+
+      # Range should be created if the column has not been touched before
+      @worksheet.change_column_width(0, 30)
+      expect(@worksheet.get_column_width(0)).to eq(30)
+      expect(@worksheet.cols.size).to eq(1)
+
+      # Existing range should be reused
+      @worksheet.change_column_width(0, 20)
+      expect(@worksheet.get_column_width(0)).to eq(20)
+      expect(@worksheet.cols.size).to eq(1)
+
+      # Creation of the new range should not affect previously changed columns
+      @worksheet.change_column_width(1, 30)
+      expect(@worksheet.get_column_width(1)).to eq(30)
+      expect(@worksheet.get_column_width(0)).to eq(20)
+      expect(@worksheet.cols.size).to eq(2)
+
+      @worksheet.cols.clear
+      @worksheet.cols << RubyXL::ColumnRange.new(:min => 1, :max => 9, :width => 33) # Note that this is raw width
+
+      r = @worksheet.cols.locate_range(3)
+      expect(r.min).to eq(1)
+      expect(r.max).to eq(9)
+
+      # When a column is modified at the beginning of the range, it should shrink to the right
+      @worksheet.change_column_width(0, 20)
+      expect(@worksheet.cols.size).to eq(2)
+      expect(@worksheet.get_column_width(0)).to eq(20)
+      expect(@worksheet.get_column_width(1)).to eq(32)
+
+      r = @worksheet.cols.locate_range(3)
+      expect(r.min).to eq(2)
+      expect(r.max).to eq(9)
+
+      # When a column is modified at the beginning of the range, it should shrink to the left
+      @worksheet.change_column_width(8, 30)
+      expect(@worksheet.cols.size).to eq(3)
+      expect(@worksheet.get_column_width(8)).to eq(30)
+
+      r = @worksheet.cols.locate_range(3)
+      expect(r.min).to eq(2)
+      expect(r.max).to eq(8)
+
+      # When a column is modified in the middle of the range, it should split into two
+      @worksheet.change_column_width(4, 15)
+      expect(@worksheet.cols.size).to eq(5)
+      expect(@worksheet.get_column_width(3)).to eq(32)
+
+      r = @worksheet.cols.locate_range(2)
+      expect(r.min).to eq(2)
+      expect(r.max).to eq(4)
+
+      expect(@worksheet.get_column_width(4)).to eq(15)
+
+      r = @worksheet.cols.locate_range(4)
+      expect(r.min).to eq(5)
+      expect(r.max).to eq(5)
+
+      expect(@worksheet.get_column_width(5)).to eq(32)
+
+      r = @worksheet.cols.locate_range(6)
+      expect(r.min).to eq(6)
+      expect(r.max).to eq(8)
+
+    end
+
+  end
+
+end