robust_excel_ole 1.27 → 1.32

data/spec/general_spec.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-require File.join(File.dirname(__FILE__), './spec_helper')
+require_relative 'spec_helper'
 
 $VERBOSE = nil
 
@@ -9,6 +9,10 @@ include RobustExcelOle
 
 module RobustExcelOle
 
+  using StringRefinement
+  using ToReoRefinement
+  using FindAllIndicesRefinement
+
   describe General do
 
     before(:all) do
@@ -31,6 +35,8 @@ module RobustExcelOle
       @simple_file_xlsx = @dir + '/workbook.xlsx'
       @network_path = "N:/data/workbook.xls"
       @hostname_share_path = "//DESKTOP-A3C5CJ6/spec/data/workbook.xls"
+      @network_path_downcase = "n:/data/workbook.xls"
+      @hostname_share_path_downcase = "//desktop-a3c5cj6/spec/data/workbook.xls"
       @simple_file_extern = "D:/data/workbook.xls"
       @hostname_share_path = "//DESKTOP-A3C5CJ6/spec/data/workbook.xls"
     end
@@ -40,6 +46,33 @@ module RobustExcelOle
       rm_tmp(@dir)
     end
 
+    describe "find_all_indices" do
+
+      it "should find all occurrences" do
+        [1,2,3,1].find_all_indices(1).should == [0,3]
+        [1,2,3,1].find_all_indices(4).should be_empty
+        ["a","b","c","a"].find_all_indices("a").should == [0,3]
+        ["a","b","c","a"].find_all_indices("d").should be_empty
+        ["a","ö","ß","a"].find_all_indices("a").should == [0,3]
+        ["a","b","c","d"].find_all_indices("ä").should be_empty
+        ["ä","ö","ß","ä"].find_all_indices("ä").should == [0,3]
+        ["stück","öl","straße","stück"].find_all_indices("stück").should == [0,3]
+      end
+
+    end
+
+    describe "relace_umlauts, underscore" do
+
+      it "should replace umlauts" do
+        "BeforeÄÖÜäöüß²³After".replace_umlauts.should == "BeforeAeOeUeaeoeuess23After"
+      end
+
+      it "should underscore" do
+        "BeforeAfter".underscore.should == "before_after"
+      end
+
+    end
+
     describe "to_reo" do
 
       before do
@@ -47,14 +80,25 @@ module RobustExcelOle
         @book2 = Workbook.open(@listobject_file)        
       end
 
+      it "should type-lift an ListRow" do
+        worksheet = @book2.sheet(3)
+        ole_table = worksheet.ListObjects.Item(1)
+        table = Table.new(ole_table)
+        listrow = table[1]
+        listrow.values.should == [3.0, "John", 50.0, 0.5, 30.0]
+        type_lifted_listrow = listrow.ole_tablerow.to_reo
+        type_lifted_listrow.should be_a ListRow
+        type_lifted_listrow.values.should == [3.0, "John", 50.0, 0.5, 30.0]
+      end
+
       it "should type-lift an ListObject" do
         worksheet = @book2.sheet(3)
         ole_table = worksheet.ListObjects.Item(1)
         table = Table.new(ole_table)
         table.Name.should == "table3"
         table.HeaderRowRange.Value.first.should == ["Number","Person","Amount","Time","Price"]
-        table.ListRows.Count.should == 6
-        worksheet[3,4].Value.should == "Number"
+        table.ListRows.Count.should == 13
+        worksheet[3,4].should == "Number"
       end
 
       it "should type-lift an Excel" do
@@ -92,18 +136,34 @@ module RobustExcelOle
         @book1.sheet(1).to_reo.should == @book1.sheet(1)
         @book1.excel.to_reo.should == @book1.excel
         @book1.sheet(1).range([1,1]).to_reo.should == @book1.sheet(1).range([1,1])
+        @book2.sheet(3).table(1).to_reo.should == @book2.sheet(3).table(1)
+        @book2.sheet(3).table(1).should == @book2.sheet(3).table(1)
+        @book2.sheet(3).table(1)[1].to_reo.should == @book2.sheet(3).table(1)[1]
+      end
+
+      it "should raise error" do
+        expect{
+          WIN32OLE.new('WScript.Network').to_reo
+        }.to raise_error(TypeREOError)
       end
 
     end
 
-    describe "General.uplift_to_reo" do
+    describe "General.init_reo_for_win32ole" do
 
       before do
         @book1 = Workbook.open(@simple_file, :visible => true)
       end
 
+      it "should not overwrite methods" do
+        RobustExcelOle::Excel.define_method(:ComputerName){ "computer" }
+        network = WIN32OLE.new('WScript.Network')
+        computername = network.ComputerName
+        General.init_reo_for_win32ole
+        network.ComputerName.should == computername
+      end
+
       it "should apply reo-methods to win32ole objects" do
-        General.uplift_to_reo  
         ole_book1 = @book1.ole_workbook
         sheet1 = ole_book1.sheet(1)
         sheet1.should be_a Worksheet
@@ -249,13 +309,6 @@ module RobustExcelOle
           canonize("this../.i.s/.../..the/..../pa.th/").should == "this../.i.s/.../..the/..../pa.th"
         end
 
-=begin
-        it "should downcase" do
-          canonize("/This/IS/tHe/path").should == "/this/is/the/path"
-          canonize("///THIS/.///./////iS//the/../PatH/////").should == "/this/is/path"
-        end
-=end
-
         it "should raise an error for no strings" do
           expect{
             canonize(1)
@@ -267,6 +320,8 @@ module RobustExcelOle
           General.canonize(@network_path).should == @network_path
           General.canonize(@simple_file).should == @simple_file
           General.canonize(@simple_file_extern).should == @simple_file_extern
+          General.canonize(@hostname_share_path_downcase).should == @network_path
+          General.canonize(@network_path_downcase).should == @network_path_downcase
         end
 
       end
@@ -277,12 +332,18 @@ module RobustExcelOle
       it "should create a path" do
         path1 = "this" / "is" / "a" / "path"
         path1.should == "this/is/a/path"
-        path2 = "this" / "is" / "a" / "path" / 
-        #path2.should == "this/is/a/path/"
-        path3 = "this" / 
-        #path3.should == "this/"
-        path4 = "this" / nil
-        path4.should == "this"
+        path2 = "this" / nil
+        path2.should == "this"
+        path3 = "N:/E2" / "C:/gim/E2/workbook.xls"
+        path3.should == "C:/gim/E2/workbook.xls"
+        path4 = "N:/E2/" / "/gim/E2/workbook.xls"
+        path4.should == "/gim/E2/workbook.xls"
+        path5 = "N:/E2/" / "gim/E2/workbook.xls"
+        path5.should == "N:/E2/gim/E2/workbook.xls"
+        path6 = "N:/E2" / "spec/data/workbook.xls"
+        path6.should == "N:/E2/spec/data/workbook.xls"
+        path7 = "N:/E2" / "c:/gim/E2/workbook.xls"
+        path7.should == "c:/gim/E2/workbook.xls"
       end
     end
 

data/spec/list_object_spec.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-require File.join(File.dirname(__FILE__), './spec_helper')
+require_relative 'spec_helper'
 
 $VERBOSE = nil
 
@@ -10,7 +10,7 @@ include General
 describe ListObject do
  
   before(:all) do
-    excel = Excel.new(:reuse => true)
+    excel = Excel.new(reuse: true)
     open_books = excel == nil ? 0 : excel.Workbooks.Count
     puts "*** open books *** : #{open_books}" if open_books > 0
     Excel.kill_all
@@ -19,16 +19,30 @@ describe ListObject do
   before do
     @dir = create_tmpdir
     @listobject_file = @dir + '/workbook_listobjects.xlsx'
-    @book = Workbook.open(@listobject_file, :visible => true)
+    @book = Workbook.open(@listobject_file, visible: true)
     @sheet = @book.sheet(3)
   end
 
   after do
-    @book.close(:if_unsaved => :forget)
+    @book.close(if_unsaved: :forget)
     Excel.kill_all
     rm_tmp(@dir)
   end
 
+  describe "accessing a table" do
+
+    it "should access a table via its number" do
+      table = @sheet.table(1)
+      table.Name.should == "table3"
+    end
+
+    it "should access a table via its name" do
+      table = @sheet.table("table3")
+      table.Name.should == "table3"
+    end
+
+  end
+
   describe "creating" do
 
     context "with standard" do
@@ -38,7 +52,15 @@ describe ListObject do
         table.Name.should == "table_name"
         table.HeaderRowRange.Value.first.should == ["Person","Amount"]
         table.ListRows.Count.should == 3
-        @sheet[1,1].Value.should == "Person"
+        @sheet[1,1].should == "Person"
+      end
+
+      it "should create a new table with umlauts" do
+        table = Table.new(@sheet, "lösung", [1,1], 3, ["Verkäufer","Straße"])
+        table.Name.encode_value.should == "lösung"
+        table.HeaderRowRange.Value.first.encode_value.should == ["Verkäufer","Straße"]
+        table.ListRows.Count.should == 3
+        @sheet[1,1].encode_value.should == "Verkäufer"
       end
 
       it "should do the idempotence" do
@@ -53,8 +75,9 @@ describe ListObject do
         table = Table.new(ole_table)
         table.Name.should == "table3"
         table.HeaderRowRange.Value.first.should == ["Number","Person","Amount","Time","Price"]
-        table.ListRows.Count.should == 6
-        @sheet[3,4].Value.should == "Number"
+        table.ListRows.Count.should == 13
+        @sheet[3,4].should == "Number"
+        table.position.should == [3,4]
       end
 
       it "should type-lift a Win32ole list object into a RobustExcelOle list object with table name" do
@@ -62,8 +85,8 @@ describe ListObject do
         table = Table.new(@sheet, "table3")
         table.Name.should == "table3"
         table.HeaderRowRange.Value.first.should == ["Number","Person","Amount","Time","Price"]
-        table.ListRows.Count.should == 6
-        @sheet[3,4].Value.should == "Number"
+        table.ListRows.Count.should == 13
+        @sheet[3,4].should == "Number"
       end
 
       it "should type-lift a Win32ole list object into a RobustExcelOle list object with item number" do
@@ -71,8 +94,8 @@ describe ListObject do
         table = Table.new(@sheet, 1)
         table.Name.should == "table3"
         table.HeaderRowRange.Value.first.should == ["Number","Person","Amount","Time","Price"]
-        table.ListRows.Count.should == 6
-        @sheet[3,4].Value.should == "Number"
+        table.ListRows.Count.should == 13
+        @sheet[3,4].should == "Number"
       end
 
       it "should simply create a new table from a ole-worksheet" do
@@ -80,7 +103,7 @@ describe ListObject do
         table.Name.should == "table_name"
         table.HeaderRowRange.Value.first.should == ["Person","Amount"]
         table.ListRows.Count.should == 3
-        @sheet[1,1].Value.should == "Person"
+        @sheet[1,1].should == "Person"
       end
 
       it "should type-lift a Win32ole list object into a RobustExcelOle list object with table name" do
@@ -88,8 +111,8 @@ describe ListObject do
         table = Table.new(@sheet.ole_worksheet, "table3")
         table.Name.should == "table3"
         table.HeaderRowRange.Value.first.should == ["Number","Person","Amount","Time","Price"]
-        table.ListRows.Count.should == 6
-        @sheet[3,4].Value.should == "Number"
+        table.ListRows.Count.should == 13
+        @sheet[3,4].should == "Number"
       end
 
       it "should type-lift a Win32ole list object into a RobustExcelOle list object with item number" do
@@ -97,60 +120,151 @@ describe ListObject do
         table = Table.new(@sheet.ole_worksheet, 1)
         table.Name.should == "table3"
         table.HeaderRowRange.Value.first.should == ["Number","Person","Amount","Time","Price"]
-        table.ListRows.Count.should == 6
-        @sheet[3,4].Value.should == "Number"
+        table.ListRows.Count.should == 13
+        @sheet[3,4].should == "Number"
       end
 
     end
 
   end
 
-  describe "getting and setting values" do
+  describe "each" do
 
-    context "with new table" do
+    before do
+      @table1 = @sheet.table(1)
+    end
 
-      before do
-        @table = Table.new(@sheet, "table_name", [1,1], 3, ["Person","Amo%untSales"])
-        @table_row1 = @table[1]
+    it "should traverse through list rows" do
+      @table1.each.with_index do |listrow, i|
+        listrow.values.should == [3.0, "John", 50.0, 0.5, 30] if i == 0        
+        listrow.values.should == [2.0, "Fred", nil, 0.5416666666666666, 40] if i == 1
+        listrow.values.should == [nil, nil, nil, nil, nil] if i == 2
       end
+    end
+
+  end
+
+  describe "benchmarking for accessing a listrow" do
 
-      it "should read and set values via alternative column names" do
-        @table_row1.person.should be nil
-        @table_row1.person = "John"
-        @table_row1.person.should == "John"
-        @sheet[2,1].Value.should == "John"
-        @table_row1.amount_sales.should be nil
-        @table_row1.amount_sales = 42
-        @table_row1.amount_sales.should == 42
-        @sheet[2,2].Value.should == 42
-        @table_row1.Person = "Herbert"
-        @table_row1.Person.should == "Herbert"
-        @sheet[2,1].Value.should == "Herbert"
-        @table_row1.AmountSales = 80
-        @table_row1.AmountSales.should == 80
-        @sheet[2,2].Value.should == 80
+    it "should access the last row" do
+      rows =  150
+      table = Table.new(@sheet.ole_worksheet, "table_name", [20,1], rows, ["Index","Person", "Time", "Price", "Sales", "Length", "Size", "Width", "Weight", "Income", "Outcome", "Holiday", "Gender", "Sex", "Tallness", "Kindness", "Music", "Activity", "Goal", "Need"])
+      (1..rows).each do |row|
+        table[row].values = [12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason"]
       end
+      table[rows].values = [12345123, "Peterson", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason", 12345678, "Johnason"]
+      sleep 1
+      start_time = Time.now
+      listrow = table[{"Index" => 12345123, "Person" => "Peterson"}]
+      end_time = Time.now
+      duration = end_time - start_time
+      puts "duration: #{duration}"
+      puts "listrow.values: #{listrow.values}"
+    end
+
+  end
 
+  describe "accessing a listrow" do
+
+    before do
+      @table1 = @sheet.table(1)
     end
 
-    context "with type-lifted ole list object" do
+    it "should access a listrow given its number" do
+      listrow = @table1[2]
+      listrow.should be_a ListRow
+      listrow.values.should == [2.0, "Fred", nil, 0.5416666666666666, 40]
+    end   
 
-      before do
-        ole_table = @sheet.ListObjects.Item(1)
-        @table = Table.new(ole_table)
-        @table_row1 = @table[1]
-      end
+    it "should access a listrow via a multiple-column key" do
+      listrow = @table1[{"Number" => 3, "Person" => "Angel"}]
+      listrow.should be_a ListRow
+      listrow.values.should == [3.0, "Angel", 100, 0.6666666666666666, 60]
+    end
 
-      it "should set and read values" do
-        @table_row1.number.should == 3
-        @table_row1.number = 1
-        @table_row1.number.should == 1
-        @sheet[4,4].Value.should == 1
-        @table_row1.person.should == "John"
-        @table_row1.person = "Herbert"
-        @table_row1.person.should == "Herbert"
-        @sheet[4,5].Value.should == "Herbert"
-      end
+    it "should access a listrow with key not case-sensitive or symbol" do
+      @table1[{"Person" => "Angel"}].values.should == [3.0, "Angel", 100, 0.6666666666666666, 60]
+      @table1[{"PERSON" => "Angel"}].values.should == [3.0, "Angel", 100, 0.6666666666666666, 60]
+      @table1[{"person" => "Angel"}].values.should == [3.0, "Angel", 100, 0.6666666666666666, 60]
+      @table1[{:person => "Angel"}].values.should == [3.0, "Angel", 100, 0.6666666666666666, 60]
+    end
+
+    it "should yield nil if there is no match" do
+      @table1[{"Number" => 5, "Person" => "Angel"}].should == nil
+      @table1[{"Number" => 5, "Person" => "Angel"}, limit: :first].should == nil
+    end
+
+    it "should yield nil if there is no match" do
+      @table1[{"Number" => 5, "Person" => "Angel"}, limit: 1].should == []
+    end
+
+    #it "should raise an error if the key contains no existing columns" do
+    #  expect{
+     #   @table1[{"Number" => 3, "Persona" => "Angel"}]
+     #   }.to raise_error(TableError)
+     #end
+
+    it "should access one matching listrow" do
+      @table1[{"Number" => 3}, limit: :first].values.should == [3.0, "John", 50.0, 0.5, 30]
+    end
+
+    it "should access one matching listrow" do
+      @table1[{"Number" => 3}, limit: 1].map{|l| l.values}.should == [[3.0, "John", 50.0, 0.5, 30]]
+    end
+ 
+    it "should access two matching listrows" do
+      @table1[{"Number" => 3}, limit: 2].map{|l| l.values}.should == [[3.0, "John", 50.0, 0.5, 30],[3.0, "Angel", 100, 0.6666666666666666, 60]]
+    end
+
+    it "should access four matching listrows" do
+      @table1[{"Number" => 3}, limit: 4].map{|l| l.values}.should == [[3.0, "John", 50.0, 0.5, 30],[3.0, "Angel", 100, 0.6666666666666666, 60],
+                                                               [3.0, "Eiffel", 50.0, 0.5, 30], [3.0, "Berta", nil, 0.5416666666666666, 40]]
+    end
+
+    it "should access all matching listrows" do
+      @table1[{"Number" => 3}, limit: nil].map{|l| l.values}.should == [[3.0, "John", 50.0, 0.5, 30],
+                                                                 [3.0, "Angel", 100, 0.6666666666666666, 60],
+                                                                 [3.0, "Eiffel", 50.0, 0.5, 30], 
+                                                                 [3.0, "Berta", nil, 0.5416666666666666, 40],
+                                                                 [3.0, "Martha", nil, nil, nil],
+                                                                 [3.0, "Paul", 40.0, 0.5, 80]]
+    end
+
+    it "should access listrows containing umlauts" do
+      #@table1[1].values = [1, "Sören", 20.0, 0.1, 40]
+      #@table1[{"Number" => 1, "Person" => "Sören"}].values.encode_value.should == [1, "Sören", 20.0, 0.1, 40]
+      @table1.add_column("Straße", 3, ["ä","ö","ü","ß","²","³","g","h","i","j","k","l","m"])
+      @table1[1].values = [1, "Sören", "Lösung", 20.0, 0.1, 40]
+      @table1[1].values.should == [1, "Sören", "Lösung", 20.0, 0.1, 40]
+      @table1[{"Number" => 1, "Person" => "Sören"}].values.encode_value.should == [1, "Sören", "Lösung", 20.0, 0.1, 40]
+      @table1[{"Number" => 1, "Straße" => "Lösung"}].values.encode_value.should == [1, "Sören", "Lösung", 20.0, 0.1, 40]
+    end
+
+  end
+
+  describe "#value" do
+
+    before do
+      @table1 = @sheet.table(1)
+    end
+
+    it "should return values" do
+      table_value = [
+        ["Number", "Person", "Amount", "Time", "Price"],
+        [3.0, "John", 50.0, 0.5, 30.0],
+        [2.0, "Fred", nil, 0.5416666666666666, 40.0],
+        [nil, nil, nil, nil, nil],
+        [3.0, "Angel", 100.0, 0.6666666666666666, 60.0],
+        [nil, nil, nil, nil, nil],
+        [1.0, "Werner", 40.0, 0.5, 80.0],
+        [3.0, "Eiffel", 50.0, 0.5, 30.0],
+        [3.0, "Berta", nil, 0.5416666666666666, 40.0],
+        [nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil],
+        [3.0, "Martha", nil, nil, nil],
+        [3.0, "Paul", 40.0, 0.5, 80.0],
+        [1.0, "Napoli", 20.0, 0.4166666666666667, 70.0]]
+      @table1.value.should == table_value
     end
 
   end
@@ -163,17 +277,17 @@ describe ListObject do
     end
 
     it "should read contents of a column" do
-      @table.column_values("Person").should == ["John","Fred",nil,"Angel",nil,"Werner"]
+      @table.column_values("Person").should == ["John","Fred",nil,"Angel",nil,"Werner","Eiffel","Berta",nil,nil,"Martha","Paul","Napoli"]
       expect{
         @table.column_values("P")
       }.to raise_error(TableError)
     end
 
     it "should set contents of a column" do
-      @table.set_column_values("Person",["H",nil,nil,nil,"G","W"])
-      @table.ListColumns.Item(2).Range.Value.should == [["Person"],["H"],[nil],[nil],[nil],["G"],["W"]]
+      @table.set_column_values("Person",["H",nil,nil,nil,"G","W",nil,nil,nil,nil,nil,nil,nil])
+      @table.ListColumns.Item(2).Range.Value.should == [["Person"],["H"],[nil],[nil],[nil],["G"],["W"],[nil],[nil],[nil],[nil],[nil],[nil],[nil]]
       @table.set_column_values("Person",["T","Z"])
-      @table.ListColumns.Item(2).Range.Value.should == [["Person"],["T"],["Z"],[nil],[nil],["G"],["W"]]
+      @table.ListColumns.Item(2).Range.Value.should == [["Person"],["T"],["Z"],[nil],[nil],["G"],["W"],[nil],[nil],[nil],[nil],[nil],[nil],[nil]]
       expect{
         @table.set_column_values("P",["H",nil,nil,nil,"G","W"])
       }.to raise_error(TableError)
@@ -183,7 +297,7 @@ describe ListObject do
       @table.row_values(1).should == [3.0, "John", 50.0, 0.5, 30]
       @table[1].values.should == [3.0, "John", 50.0, 0.5, 30]
       expect{
-        @table.row_values(9)
+        @table.row_values(14)
       }.to raise_error(TableError)
     end
 
@@ -196,10 +310,21 @@ describe ListObject do
       @table[1].set_values([4, "John"])
       @table.ListRows.Item(1).Range.Value.first.should == [4, "John", 20.0, 0.1, 40]
       expect{
-        @table.set_row_values(9, [5, "George", 30.0, 0.2, 50])
+        @table.set_row_values(14, [5, "George", 30.0, 0.2, 50])
       }.to raise_error(TableError)
     end
 
+    it "should set contents of an incomplete row " do
+      @table[1].values = [2, "Merlin", 20.0, 0.1, 40]
+      @table[1].values = [4, "John"]
+      @table.ListRows.Item(1).Range.Value.first.should == [4, "John", 20.0, 0.1, 40]
+    end
+
+    it "should set contents of a row with umlauts" do
+      @table[1].values = [1, "Sören", 20.0, 0.1, 40]
+      @table.ListRows.Item(1).Range.Value.first.encode_value.should == [1, "Sören", 20.0, 0.1, 40]
+    end
+
   end
 
   describe "renaming, adding and deleting columns and rows" do
@@ -232,9 +357,15 @@ describe ListObject do
     end
 
     it "should add a column with contents" do
-      @table.add_column("column_name", 3, ["a","b","c","d","e","f"])
+      @table.add_column("column_name", 3, ["a","b","c","d","e","f","g","h","i","j","k","l","m"])
       column_names = @table.HeaderRowRange.Value.first.should == ["Number","Person","column_name","Amount","Time","Price"]
-      @table.ListColumns.Item(3).Range.Value.should == [["column_name"],["a"],["b"],["c"],["d"],["e"],["f"]]
+      @table.ListColumns.Item(3).Range.Value.should == [["column_name"],["a"],["b"],["c"],["d"],["e"],["f"],["g"],["h"],["i"],["j"],["k"],["l"],["m"]]
+    end
+
+    it "should add a column with umlauts" do
+      @table.add_column("Sören", 3, ["ä","ö","ü","ß","²","³","g","h","i","j","k","l","m"])
+      column_names = @table.HeaderRowRange.Value.first.encode_value.should == ["Number","Person","Sören","Amount","Time","Price"]
+      @table.ListColumns.Item(3).Range.Value.map{|v| v.encode_value}.should == [["Sören"],["ä"],["ö"],["ü"],["ß"],["²"],["³"],["g"],["h"],["i"],["j"],["k"],["l"],["m"]]
     end
 
     it "should delete a column" do
@@ -258,7 +389,7 @@ describe ListObject do
       listrows.Item(2).Range.Value.first.should == [nil,nil,nil,nil,nil]
       listrows.Item(3).Range.Value.first.should == [2.0, "Fred", nil, 0.5416666666666666, 40]
       expect{
-        @table.add_row(9)
+        @table.add_row(16)
       }.to raise_error(TableError)
     end
 
@@ -270,24 +401,29 @@ describe ListObject do
       listrows.Item(3).Range.Value.first.should == [2.0, "Fred", nil, 0.5416666666666666, 40]
     end
 
+    it "should add a row with contents with umlauts" do
+      @table.add_row(1, [2.0, "Sören", 30.0, 0.25, 40])
+      @table.ListRows.Item(1).Range.Value.first.encode_value.should == [2.0, "Sören", 30.0, 0.25, 40]
+    end
+
     it "should delete a row" do
       @table.delete_row(4)
       listrows = @table.ListRows
       listrows.Item(5).Range.Value.first.should == [1,"Werner",40,0.5, 80]
       listrows.Item(4).Range.Value.first.should == [nil,nil,nil,nil,nil]
       expect{
-        @table.delete_row(8)
+        @table.delete_row(15)
       }.to raise_error(TableError)
     end
 
     it "should delete the contents of a column" do
-      @table.ListColumns.Item(3).Range.Value.should == [["Amount"],[50],[nil],[nil],[100],[nil],[40]]
+      @table.ListColumns.Item(3).Range.Value.should == [["Amount"],[50],[nil],[nil],[100],[nil],[40],[50],[nil],[nil],[nil],[nil],[40],[20]]
       @table.delete_column_values(3)
       @table.HeaderRowRange.Value.first.should == ["Number","Person", "Amount", "Time","Price"]
-      @table.ListColumns.Item(3).Range.Value.should == [["Amount"],[nil],[nil],[nil],[nil],[nil],[nil]]
-      @table.ListColumns.Item(1).Range.Value.should == [["Number"],[3],[2],[nil],[3],[nil],[1]]
+      @table.ListColumns.Item(3).Range.Value.should == [["Amount"],[nil],[nil],[nil],[nil],[nil],[nil],[nil],[nil],[nil],[nil],[nil],[nil],[nil]]
+      @table.ListColumns.Item(1).Range.Value.should == [["Number"],[3],[2],[nil],[3],[nil],[1],[3],[3],[nil],[nil],[3],[3],[1]]
       @table.delete_column_values("Number")
-      @table.ListColumns.Item(1).Range.Value.should == [["Number"],[nil],[nil],[nil],[nil],[nil],[nil]]
+      @table.ListColumns.Item(1).Range.Value.should == [["Number"],[nil],[nil],[nil],[nil],[nil],[nil],[nil],[nil],[nil],[nil],[nil],[nil],[nil]]
       expect{
         @table.delete_column_values("N")
       }.to raise_error(TableError)
@@ -301,13 +437,13 @@ describe ListObject do
       @table[1].delete_values
       @table.ListRows.Item(1).Range.Value.first.should == [nil,nil,nil,nil,nil]
       expect{
-        @table.delete_row_values(9)
+        @table.delete_row_values(14)
       }.to raise_error(TableError)
     end
 
     it "should delete empty rows" do
       @table.delete_empty_rows
-      @table.ListRows.Count.should == 4
+      @table.ListRows.Count.should == 9
       @table.ListRows.Item(1).Range.Value.first.should == [3.0, "John", 50.0, 0.5, 30]
       @table.ListRows.Item(2).Range.Value.first.should == [2.0, "Fred", nil, 0.5416666666666666, 40]
       @table.ListRows.Item(3).Range.Value.first.should == [3, "Angel", 100, 0.6666666666666666, 60]
@@ -326,21 +462,58 @@ describe ListObject do
 
   describe "find all cells of a given value" do
 
-    before do
-      ole_table = @sheet.ListObjects.Item(1)
-      @table = Table.new(ole_table)
+    context "with standard" do
+
+      before do
+        ole_table = @sheet.ListObjects.Item(1)
+        @table = Table.new(ole_table)
+      end
+
+      it "should find all cells" do
+        cells = @table.find_cells(40)
+        cells[0].Row.should == 5
+        cells[0].Column.should == 8
+        cells[1].Row.should == 9
+        cells[1].Column.should == 6
+      end
+
     end
 
-    it "should find all cells" do
-      cells = @table.find_cells(40)
-      cells[0].Row.should == 5
-      cells[0].Column.should == 8
-      cells[1].Row.should == 9
-      cells[1].Column.should == 6
+    context "with umlauts" do
+
+      before do
+        @table = Table.new(@sheet, "lösung", [1,1], 3, ["Verkäufer","Straße"])
+        @table[1].values = ["sören", "stück"]
+        @table[2].values = ["stück", "glück"]
+        @table[3].values = ["soße",  "stück"]
+      end
+
+      it "should find all cells" do
+        cells = @table.find_cells("stück")
+        cells[0].Row.should == 2
+        cells[0].Column.should == 2
+        cells[1].Row.should == 3
+        cells[1].Column.should == 1
+        cells[2].Row.should == 4
+        cells[2].Column.should == 2
+      end
+
     end
   
   end
 
+  describe "==" do
+
+    it "should yield true" do
+      (@sheet.table(1) == @sheet.table(1)).should be true
+    end
+
+    it "should yield false" do
+      table2 = Table.new(@sheet, "lösung", [1,1], 3, ["Verkäufer","Straße"])
+      (table2 == @sheet.table(1)).should be false
+    end
+  end
+
   describe "sort the table" do
 
     before do
@@ -350,10 +523,15 @@ describe ListObject do
 
     it "should sort the table according to first table" do
       @table.sort("Number")
-      @table.ListRows.Item(1).Range.Value.first.should == [1,"Werner",40,0.5, 80]
-      @table.ListRows.Item(2).Range.Value.first.should == [2, "Fred", nil, 0.5416666666666666, 40]     
-      @table.ListRows.Item(3).Range.Value.first.should == [3, "John", 50.0, 0.5, 30]
-      @table.ListRows.Item(4).Range.Value.first.should == [3, "Angel", 100, 0.6666666666666666, 60]
+      @table.ListRows.Item(1).Range.Value.first.should == [1, "Werner",40,0.5, 80]
+      @table.ListRows.Item(2).Range.Value.first.should == [1, "Napoli", 20.0, 0.4166666666666667, 70.0]
+      @table.ListRows.Item(3).Range.Value.first.should == [2, "Fred", nil, 0.5416666666666666, 40]     
+      @table.ListRows.Item(4).Range.Value.first.should == [3, "John", 50.0, 0.5, 30]
+      @table.ListRows.Item(5).Range.Value.first.should == [3, "Angel", 100, 0.6666666666666666, 60]
+      @table.ListRows.Item(6).Range.Value.first.should == [3, "Eiffel", 50.0, 0.5, 30]
+      @table.ListRows.Item(7).Range.Value.first.should == [3, "Berta", nil, 0.5416666666666666, 40]
+      @table.ListRows.Item(8).Range.Value.first.should == [3, "Martha", nil, nil, nil]
+      @table.ListRows.Item(9).Range.Value.first.should == [3, "Paul", 40.0, 0.5, 80]
     end
 
   end