fireruby 0.2.2-i586-linux → 0.3.0-i586-linux

data/test/AddRemoveUserTest.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require_gem 'fireruby'
+
+include FireRuby
+
+class AddRemoveUserTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}add_remove_user_unit_test.fdb"
+
+   def setup
+      # Remove existing database files.
+      @database = Database.new(DB_FILE)
+      if File.exist?(DB_FILE)
+         @database.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+   end
+
+   def teardown
+      # Remove existing database files.
+      if File.exist?(DB_FILE)
+         @database.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+   end
+
+   def test01
+      sm = ServiceManager.new('localhost')
+      sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      au = AddUser.new('newuser', 'password', 'first', 'middle', 'last')
+      au.execute(sm)
+
+      cxn = @database.connect('newuser', 'password')
+      cxn.close
+
+      ru = RemoveUser.new('newuser')
+      ru.execute(sm)
+
+      begin
+         cxn = @database.connect('newuser', 'password')
+         cxn.close
+         assert(false, "Able to connect as supposedly removed user.")
+      rescue FireRubyException
+      end
+   end
+end

data/test/BackupRestoreTest.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require_gem 'fireruby'
+
+include FireRuby
+
+class BackupRestoreTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}backup_restore_unit_test.fdb"
+   BACKUP_FILE = "#{CURDIR}#{File::SEPARATOR}database.bak"
+
+   def setup
+      # Remove existing database files.
+      if File.exist?(DB_FILE)
+         db = Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+
+      if File.exist?(BACKUP_FILE)
+         File.delete(BACKUP_FILE)
+      end
+
+      # Create and populate the database files.
+      @database = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('create table test(id integer)')
+         cxn.execute_immediate('insert into test values (1000)')
+         cxn.execute_immediate('insert into test values (2000)')
+         cxn.execute_immediate('insert into test values (NULL)')
+         cxn.execute_immediate('insert into test values (3000)')
+         cxn.execute_immediate('insert into test values (4000)')
+      end
+   end
+
+   def teardown
+      # Remove existing database files.
+      if File.exist?(DB_FILE)
+         db = Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+
+      if File.exist?(BACKUP_FILE)
+         File.delete(BACKUP_FILE)
+      end
+   end
+
+   def test01
+      sm = ServiceManager.new('localhost')
+      sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      b = Backup.new(DB_FILE, BACKUP_FILE)
+      b.execute(sm)
+
+      assert(File.exist?(BACKUP_FILE))
+      @database.drop(DB_USER_NAME, DB_PASSWORD)
+      assert(File.exists?(DB_FILE) == false)
+
+      r = Restore.new(BACKUP_FILE, DB_FILE)
+      r.execute(sm)
+      sm.disconnect
+
+      assert(File.exist?(DB_FILE))
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         total = 0
+         cxn.execute_immediate('select * from test') do |row|
+            assert([1000, 2000, 3000, 4000, nil].include?(row[0]))
+            total += 1
+         end
+         assert(total == 5)
+      end
+   end
+
+   def test02
+      sm = ServiceManager.new('localhost')
+      sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      b = Backup.new(DB_FILE, BACKUP_FILE)
+      b.metadata_only = true
+      b.execute(sm)
+
+      assert(File.exist?(BACKUP_FILE))
+      @database.drop(DB_USER_NAME, DB_PASSWORD)
+      assert(File.exists?(DB_FILE) == false)
+
+      r = Restore.new(BACKUP_FILE, DB_FILE)
+      r.execute(sm)
+      sm.disconnect
+
+      assert(File.exist?(DB_FILE))
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('select count(*) from test') do |row|
+            assert(row[0] == 0)
+         end
+      end
+   end
+end

data/test/ConnectionTest.rb

@@ -16,7 +16,7 @@ class ConnectionTest < Test::Unit::TestCase
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
 
-      @database    = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+      @database    = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
       @connections = []
    end
    

data/test/DDLTest.rb

@@ -15,7 +15,7 @@ class DDLTest < Test::Unit::TestCase
       if File::exist?(DB_FILE)
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
-      @database = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+      @database = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
    end
    
    def teardown
@@ -26,25 +26,33 @@ class DDLTest < Test::Unit::TestCase
    
    def test01
       @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
-         cxn.execute_immediate('CREATE TABLE DDL_TABLE_01 (TABLEID '\
-                               'INTEGER NOT NULL, '\
-                               'FIELD01 FLOAT, FIELD02 CHAR(50), '\
-                               'FIELD03 BIGINT, FIELD04 TIMESTAMP '\
-                               'NOT NULL, FIELD05 VARCHAR(600))')
+         begin
+            cxn.execute_immediate('CREATE TABLE DDL_TABLE_01 (TABLEID '\
+                                  'INTEGER NOT NULL, '\
+                                  'FIELD01 FLOAT, FIELD02 CHAR(50), '\
+                                  'FIELD03 BIGINT, FIELD04 TIMESTAMP '\
+                                  'NOT NULL, FIELD05 VARCHAR(600))')
 
-         r = cxn.execute_immediate('SELECT COUNT(*) FROM DDL_TABLE_01')
-         assert(r.fetch[0] == 0)
-         r.close
+            cxn.start_transaction do |tx|
+               r = tx.execute('SELECT COUNT(*) FROM DDL_TABLE_01')
+               assert(r.fetch[0] == 0)
+               r.close
+            end
          
-         cxn.execute_immediate('ALTER TABLE DDL_TABLE_01 ADD PRIMARY KEY '\
-                               '(TABLEID)')
+            cxn.execute_immediate('ALTER TABLE DDL_TABLE_01 ADD PRIMARY KEY '\
+                                  '(TABLEID)')
                                
-         cxn.execute_immediate('CREATE UNIQUE INDEX DDL_TABLE_IDX ON '\
+            cxn.execute_immediate('CREATE UNIQUE INDEX DDL_TABLE_IDX ON '\
                                'DDL_TABLE_01 (TABLEID)')
                                
-         cxn.execute_immediate('DROP INDEX DDL_TABLE_IDX')
+            cxn.execute_immediate('DROP INDEX DDL_TABLE_IDX')
          
-         cxn.execute_immediate('DROP TABLE DDL_TABLE_01')
+            cxn.execute_immediate('DROP TABLE DDL_TABLE_01')
+         rescue Exception => error
+            puts error.message
+            error.backtrace.each {|step| puts "   #{step}"}
+            raise
+         end
       end
    end
 end

data/test/GeneratorTest.rb

@@ -13,9 +13,9 @@ class GeneratorTest < Test::Unit::TestCase
    
    def setup
       if File::exist?(DB_FILE)
-         Database.new(DB_USER_NAME, DB_PASSWORD, DB_FILE).drop
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
-      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
       @connections  = []
       
       @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))

data/test/ResultSetTest.rb

@@ -15,7 +15,7 @@ class ResultSetTest < Test::Unit::TestCase
       if File::exist?(DB_FILE)
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
-      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
       @connections  = []
       @transactions = []
       
@@ -58,12 +58,13 @@ class ResultSetTest < Test::Unit::TestCase
    end
    
    def test01
-      s = Statement.new(@connections[0], @transactions[0],
-                        "SELECT * FROM TEST_TABLE ORDER BY TESTID", 3)
+      r = ResultSet.new(@connections[0], @transactions[0],
+                        "SELECT * FROM TEST_TABLE ORDER BY TESTID", 3, nil)
       
-      r = ResultSet.new(s)
-      
-      assert(r.statement == s)
+      assert(r.connection == @connections[0])
+      assert(r.transaction == @transactions[0])
+      assert(r.sql == "SELECT * FROM TEST_TABLE ORDER BY TESTID")
+      assert(r.dialect == 3)
       
       assert(r.fetch != nil)
       assert(r.fetch.class == Row)
@@ -71,8 +72,10 @@ class ResultSetTest < Test::Unit::TestCase
       assert(r.fetch[1] == 'Record Four.')
       r.fetch
       assert(r.fetch == nil)
+      r.close
       
-      r = ResultSet.new(s)
+      r = ResultSet.new(@connections[0], @transactions[0],
+                        "SELECT * FROM TEST_TABLE ORDER BY TESTID", 3, nil)
       assert(r.column_count == 2)
       assert(r.column_name(0) == 'TESTID')
       assert(r.column_name(1) == 'TESTINFO')
@@ -86,12 +89,43 @@ class ResultSetTest < Test::Unit::TestCase
       assert(r.column_alias(1) == 'TESTINFO')
       assert(r.column_alias(3) == nil)
       assert(r.column_alias(-1) == nil)
+      r.close
       
-      r = ResultSet.new(s)
+      r = ResultSet.new(@connections[0], @transactions[0],
+                        "SELECT * FROM TEST_TABLE ORDER BY TESTID", 3, nil)
       total = 0
       r.each do |row|
          total += 1
       end
       assert(total == 5)
+      r.close
+   end
+
+   def test02
+      r = ResultSet.new(@connections[0], @transactions[0],
+                        'select * from test_table where testid between ? and ?',
+                        3, [20, 40])
+      assert(r.exhausted? == false)
+      total = 0
+      r.each {|row| total += 1}
+      assert(total ==3)
+   end
+
+   def test03
+      begin
+         ResultSet.new(@connections[0], @transactions[0],
+                       "insert into test_table values(?, ?)", 3,
+                       [100, 'Should fail.'])
+         assert(false, "Created result set with non-query SQL statement.")
+      rescue FireRubyException
+      end
+
+      begin
+         ResultSet.new(@connections[0], @transactions[0],
+                       "select * from test_table where testid = ?", 3,
+                       [])
+         assert(false, 'Created result set with insufficient parameters.')
+      rescue FireRubyException
+      end
    end
 end

data/test/RowCountTest.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require_gem 'fireruby'
+
+include FireRuby
+
+class RowCountTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}row_count_test.fdb"
+
+   def setup
+      # Create the database for use in testing.
+      if File.exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      @database = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      
+      # Create the test table.
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('create table test(id integer)')
+      end
+   end
+   
+   
+   def teardown
+      if File.exist?(DB_FILE)
+         @database.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+   end
+   
+   def test01
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.start_transaction do |tx|
+            assert(cxn.execute_immediate('insert into test values (1000)') == 1)
+            assert(cxn.execute_immediate('insert into test values (1000)') == 1)
+            assert(cxn.execute('insert into test values (2000)', tx) == 1)
+            assert(cxn.execute('insert into test values (2000)', tx) == 1)
+            assert(tx.execute('insert into test values (3000)') == 1)
+            assert(tx.execute('insert into test values (3000)') == 1)
+            assert(tx.execute('insert into test values (4000)') == 1)
+            assert(tx.execute('insert into test values (4000)') == 1)
+            
+            assert(cxn.execute_immediate('update test set id = 10000 where '\
+                                         'id = 1000') == 2)
+            assert(cxn.execute('update test set id = 20000 where id = 2000',
+                               tx) == 2)
+            assert(tx.execute('update test set id = 30000 where id = 3000') == 2)
+            
+            s = Statement.new(cxn, tx, 'update test set id = 40000 where id = ?',
+                              3)
+            assert(s.execute_for([4000]) == 2)
+
+            
+            assert(cxn.execute_immediate('delete from test where id = 10000') == 2)
+            assert(cxn.execute('delete from test where id = 20000', tx) == 2)
+            assert(tx.execute('delete from test where id = 30000') == 2)
+         end
+      end
+   end
+end

data/test/RowTest.rb

@@ -16,19 +16,21 @@ class RowTest < Test::Unit::TestCase
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
       
-      database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+      database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
       @connection  = database.connect(DB_USER_NAME, DB_PASSWORD)
       @transaction = @connection.start_transaction
-      @statement   = Statement.new(@connection, @transaction,
-                                   'SELECT * FROM RDB$FIELDS', 3)
-      @results     = ResultSet.new(@statement)
+      @results     = ResultSet.new(@connection, @transaction,
+                                   'SELECT * FROM RDB$FIELDS', 3, nil)
       @empty       = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                       0, 0, 0, 0, 0, 0, 0, 0, 0]
+      
+      @connection.execute_immediate('create table rowtest (COL01 integer, '\
+                                    'COL02 varchar(10), COL03 integer)')
+      @connection.execute_immediate("insert into rowtest values (1, 'Two', 3)")
    end
    
    def teardown
       @results.close
-      @statement.close
       @transaction.rollback
       @connection.close
       if File::exist?(DB_FILE)
@@ -46,4 +48,90 @@ class RowTest < Test::Unit::TestCase
       assert(row[0] == 0)
       assert(row['RDB$FIELD_TYPE'] == 0)
    end
+   
+   def test02
+      sql  = 'select COL01 one, COL02 two, COL03 three from rowtest'
+      rows = @connection.execute_immediate(sql)
+      data = rows.fetch
+      
+      count = 0
+      data.each do |name, value|
+         assert(['COL01', 'COL02', 'COL03'].include?(name))
+         assert([1, 'Two', 3].include?(value))
+         count += 1
+      end
+      assert(count == 3)
+      
+      count = 0
+      data.each_key do |name|
+         assert(['COL01', 'COL02', 'COL03'].include?(name))
+         count += 1
+      end
+      assert(count == 3)
+      
+      count = 0
+      data.each_value do |value|
+         assert([1, 'Two', 3].include?(value))
+         count += 1
+      end
+      assert(count == 3)
+      
+      assert(data.fetch('COL02') == 'Two')
+      assert(data.fetch('COL04', 'LALALA') == 'LALALA')
+      assert(data.fetch('COL00') {'NOT FOUND'} == 'NOT FOUND')
+      begin
+         data.fetch('COL05')
+         assert(false, 'Row#fetch succeeded for non-existent column name.')
+      rescue IndexError
+      end
+      
+      assert(data.has_key?('COL01'))
+      assert(data.has_key?('COL10') == false)
+      
+      assert(data.has_alias?('TWO'))
+      assert(data.has_alias?('FOUR') == false)
+      
+      assert(data.has_value?(3))
+      assert(data.has_value?('LALALA') == false)
+      
+      assert(data.keys.size == 3)
+      data.keys.each do |name|
+         assert(['COL01', 'COL02', 'COL03'].include?(name))
+      end
+
+      assert(data.aliases.size == 3)
+      data.aliases.each do |name|
+         assert(['ONE', 'TWO', 'THREE'].include?(name))
+      end
+      
+      assert(data.values.size == 3)
+      data.values.each do |value|
+         assert([1, 'Two', 3].include?(value))
+      end
+      
+      array = data.select {|name, value| name == 'COL02'}
+      assert(array.size == 1)
+      assert(array[0][0] == 'COL02')
+      assert(array[0][1] == 'Two')
+      
+      array = data.to_a
+      assert(array.size == 3)
+      assert(array.include?(['COL01', 1]))
+      assert(array.include?(['COL02', 'Two']))
+      assert(array.include?(['COL03', 3]))
+      
+      hash = data.to_hash
+      assert(hash.length == 3)
+      assert(hash['COL01'] == 1)
+      assert(hash['COL02'] == 'Two')
+      assert(hash['COL03'] == 3)
+      
+      array = data.values_at('COL10', 'COL02', 'COL03')
+      assert(array.size == 3)
+      assert(array.include?('Two'))
+      assert(array.include?(3))
+      assert(array.include?(nil))
+      
+      rows.close
+   end
 end

data/test/SQLTest.rb

@@ -18,8 +18,7 @@ class SQLTest < Test::Unit::TestCase
       if File::exist?(DB_FILE)
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
-      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD,
-                                       1024, 'ASCII')
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
       @connections  = []
       @transactions = []
       
@@ -57,13 +56,17 @@ class SQLTest < Test::Unit::TestCase
                t = Time.at(t.to_i + 5)
                s.execute_for([i, i.to_s, f, t, nil, t])
             end
+
+            s.close
          end
       end
       
       @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
-      r = @connections[0].execute_immediate("SELECT COUNT(*) FROM TEST_TABLE")
-      assert(r.fetch[0] == ITERATIONS)
-      r.close
+      @connections[0].start_transaction do |tx|
+         r = tx.execute("SELECT COUNT(*) FROM TEST_TABLE")
+         assert(r.fetch[0] == ITERATIONS)
+         r.close
+      end
    end
    
    def test02
@@ -128,6 +131,7 @@ class SQLTest < Test::Unit::TestCase
          s = Statement.new(@connections[0], tx,
                            "UPDATE TEST_TABLE SET TESTSTAMP = NULL", 3)
          s.execute()
+         s.close
          
          r = tx.execute("SELECT TESTSTAMP FROM TEST_TABLE")
          total = 0
@@ -147,6 +151,7 @@ class SQLTest < Test::Unit::TestCase
                            "TESTFLOAT, TESTSTAMP) VALUES(?, ?, ?, ?)", 3)
          t = Time.new
          s.execute_for([25000, 'La la la', 3.14, t])
+         s.close
          
          # Fetch the record and check the data.
          r = tx.execute("SELECT TESTTEXT, TESTFLOAT, TESTSTAMP FROM "\
@@ -161,9 +166,12 @@ class SQLTest < Test::Unit::TestCase
       @connections[0].execute_immediate("DELETE FROM TEST_TABLE WHERE TESTID "\
                                         "IN (1, 3, 5, 7, 9, 12, 14, 16, 18, 20)")
       @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
-         r = cxn.execute_immediate("SELECT COUNT(*) FROM TEST_TABLE")
-         a = r.fetch
-         r.close
+         a = []
+         cxn.start_transaction do |tx|
+            r = tx.execute("SELECT COUNT(*) FROM TEST_TABLE")
+            a = r.fetch
+            r.close
+         end
          assert(a[0] == 11)
       end
    end

data/test/ServiceManagerTest.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require_gem 'fireruby'
+
+include FireRuby
+
+class ServiceManagerTest < Test::Unit::TestCase
+   def test01
+      sm = ServiceManager.new('localhost')
+      assert(sm.connected? == false)
+
+      assert(sm.connect(DB_USER_NAME, DB_PASSWORD) == sm)
+      assert(sm.connected?)
+
+      assert(sm.disconnect == sm)
+      assert(sm.connected? == false)
+   end
+end

data/test/StatementTest.rb

@@ -15,7 +15,7 @@ class StatementTest < Test::Unit::TestCase
       if File::exist?(DB_FILE)
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
-      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
       @connections  = []
       @transactions = []
    end
@@ -46,7 +46,7 @@ class StatementTest < Test::Unit::TestCase
       assert(s1.connection == @connections[0])
       assert(s1.transaction == @transactions[0])
       assert(s1.dialect == 3)
-      assert(s1.is_query? == true)
+      assert(s1.type == Statement::SELECT_STATEMENT)
       
       s2 = Statement.new(@connections[0],
                          @transactions[0],
@@ -56,7 +56,7 @@ class StatementTest < Test::Unit::TestCase
       assert(s2.connection == @connections[0])
       assert(s2.transaction == @transactions[0])
       assert(s2.dialect == 1)
-      assert(s2.is_query? == false)
+      assert(s2.type == Statement::DELETE_STATEMENT)
    end
    
    def test02

data/test/TransactionTest.rb

@@ -16,7 +16,7 @@ class TransactionTest < Test::Unit::TestCase
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
       
-      @database     = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, nil)
+      @database     = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
       @connections  = []
       @transactions = []
 
@@ -95,14 +95,15 @@ class TransactionTest < Test::Unit::TestCase
       sql.push("SELECT RDB$FIELD_NAME FROM RDB$FIELDS")
       @transactions.push(Transaction.new(@connections[0]))
       
-      assert(@transactions[0].execute(sql[0]) == nil)
-      assert(@transactions[0].execute(sql[1]) != nil)
-      assert(@transactions[0].execute(sql[1]).class == ResultSet)
+      assert(@transactions[0].execute(sql[0]) == 0)
+      r = @transactions[0].execute(sql[1])
+      assert(r != nil)
+      assert(r.class == ResultSet)
       
       total = 0
       @transactions[0].execute(sql[1]) do |row|
          total += 1
       end
-      assert(total = 88)
+      assert(total == 88)
    end
 end

data/test/UnitTest.rb

@@ -5,7 +5,13 @@ require 'ConnectionTest'
 require 'TransactionTest'
 require 'StatementTest'
 require 'ResultSetTest'
+require 'RowCountTest'
 require 'RowTest'
 require 'GeneratorTest'
 require 'DDLTest'
 require 'SQLTest'
+require 'ServiceManagerTest'
+if PLATFORM.include?('powerpc-darwin') == false
+   require 'BackupRestoreTest'
+   require 'AddRemoveUserTest'
+end