fireruby 0.3.2-mswin32 → 0.4.0-mswin32

data/test/RowTest.rb

@@ -3,7 +3,7 @@
 require 'TestSetup'
 require 'test/unit'
 require 'rubygems'
-require_gem 'fireruby'
+require 'fireruby'
 
 include FireRuby
 
@@ -12,6 +12,7 @@ class RowTest < Test::Unit::TestCase
    DB_FILE = "#{CURDIR}#{File::SEPARATOR}row_unit_test.fdb"
    
    def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
       if File::exist?(DB_FILE)
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
@@ -21,12 +22,42 @@ class RowTest < Test::Unit::TestCase
       @transaction = @connection.start_transaction
       @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)")
+      @empty       = [[0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER]]
+      
+      @connection.start_transaction do |tx|
+         tx.execute('create table rowtest (COL01 integer, COL02 varchar(10), '\
+                    'COL03 integer)')
+         tx.execute('create table all_types (col01 bigint, col02 blob, '\
+                    'col03 char(100), col04 date, col05 decimal(5,2), '\
+                    'col06 double precision, col07 float, col08 integer, '\
+                    'col09 numeric(10,3), col10 smallint, col11 time, '\
+                    'col12 timestamp, col13 varchar(23))')
+      end
+      @connection.start_transaction do |tx|
+         tx.execute("insert into rowtest values (1, 'Two', 3)")
+         
+         stmt = Statement.new(@connection, tx,
+                              "insert into all_types values(?, ?, ?, ?, ?, ?, "\
+                              "?, ?, ?, ?, ?, ?, ?)",
+                              3)
+         #stmt.execute_for([nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil])
+         stmt.execute_for([100000, nil, 'La la la', Date.new(2005, 10, 29),
+                           10.23, 100.751, 56.25, 12345, 19863.21, 123,
+                           Time.new, Time.new, 'The End!'])
+      end
    end
    
    def teardown
@@ -36,6 +67,7 @@ class RowTest < Test::Unit::TestCase
       if File::exist?(DB_FILE)
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
+      puts "#{self.class.name} finished." if TEST_LOGGING
    end
    
    def test01
@@ -56,7 +88,7 @@ class RowTest < Test::Unit::TestCase
       
       count = 0
       data.each do |name, value|
-         assert(['COL01', 'COL02', 'COL03'].include?(name))
+         assert(['ONE', 'TWO', 'THREE'].include?(name))
          assert([1, 'Two', 3].include?(value))
          count += 1
       end
@@ -64,7 +96,7 @@ class RowTest < Test::Unit::TestCase
       
       count = 0
       data.each_key do |name|
-         assert(['COL01', 'COL02', 'COL03'].include?(name))
+         assert(['ONE', 'TWO', 'THREE'].include?(name))
          count += 1
       end
       assert(count == 3)
@@ -76,17 +108,20 @@ class RowTest < Test::Unit::TestCase
       end
       assert(count == 3)
       
-      assert(data.fetch('COL02') == 'Two')
-      assert(data.fetch('COL04', 'LALALA') == 'LALALA')
-      assert(data.fetch('COL00') {'NOT FOUND'} == 'NOT FOUND')
+      assert(data.fetch('TWO') == 'Two')
+      assert(data.fetch('FOUR', 'LALALA') == 'LALALA')
+      assert(data.fetch('ZERO') {'NOT FOUND'} == 'NOT FOUND')
       begin
-         data.fetch('COL05')
+         data.fetch('FIVE')
          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_key?('ONE'))
+      assert(data.has_key?('TEN') == false)
+      
+      assert(data.has_column?('COL02'))
+      assert(data.has_column?('COL22') == false)
       
       assert(data.has_alias?('TWO'))
       assert(data.has_alias?('FOUR') == false)
@@ -96,6 +131,11 @@ class RowTest < Test::Unit::TestCase
       
       assert(data.keys.size == 3)
       data.keys.each do |name|
+         assert(['ONE', 'TWO', 'THREE'].include?(name))
+      end
+      
+      assert(data.names.size == 3)
+      data.names.each do |name|
          assert(['COL01', 'COL02', 'COL03'].include?(name))
       end
 
@@ -109,24 +149,24 @@ class RowTest < Test::Unit::TestCase
          assert([1, 'Two', 3].include?(value))
       end
       
-      array = data.select {|name, value| name == 'COL02'}
+      array = data.select {|name, value| name == 'TWO'}
       assert(array.size == 1)
-      assert(array[0][0] == 'COL02')
+      assert(array[0][0] == 'TWO')
       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]))
+      assert(array.include?(['ONE', 1]))
+      assert(array.include?(['TWO', 'Two']))
+      assert(array.include?(['THREE', 3]))
       
       hash = data.to_hash
       assert(hash.length == 3)
-      assert(hash['COL01'] == 1)
-      assert(hash['COL02'] == 'Two')
-      assert(hash['COL03'] == 3)
+      assert(hash['ONE'] == 1)
+      assert(hash['TWO'] == 'Two')
+      assert(hash['THREE'] == 3)
       
-      array = data.values_at('COL10', 'COL02', 'COL03')
+      array = data.values_at('TEN', 'TWO', 'THREE')
       assert(array.size == 3)
       assert(array.include?('Two'))
       assert(array.include?(3))
@@ -134,4 +174,30 @@ class RowTest < Test::Unit::TestCase
       
       rows.close
    end
+   
+   def test03
+      results = nil
+      row     = nil
+      
+      begin
+         results = @connection.execute_immediate('select * from all_types')
+         row     = results.fetch
+         
+         assert(row.get_base_type(0) == SQLType::BIGINT)
+         assert(row.get_base_type(1) == SQLType::BLOB)
+         assert(row.get_base_type(2) == SQLType::CHAR)
+         assert(row.get_base_type(3) == SQLType::DATE)
+         assert(row.get_base_type(4) == SQLType::DECIMAL)
+         assert(row.get_base_type(5) == SQLType::DOUBLE)
+         assert(row.get_base_type(6) == SQLType::FLOAT)
+         assert(row.get_base_type(7) == SQLType::INTEGER)
+         assert(row.get_base_type(8) == SQLType::NUMERIC)
+         assert(row.get_base_type(9) == SQLType::SMALLINT)
+         assert(row.get_base_type(10) == SQLType::TIME)
+         assert(row.get_base_type(11) == SQLType::TIMESTAMP)
+         assert(row.get_base_type(12) == SQLType::VARCHAR)
+      ensure
+         results.close if results != nil
+      end
+   end
 end

data/test/SQLTest.rb

@@ -3,7 +3,7 @@
 require 'TestSetup'
 require 'test/unit'
 require 'rubygems'
-require_gem 'fireruby'
+require 'fireruby'
 
 include FireRuby
 
@@ -15,6 +15,7 @@ class SQLTest < Test::Unit::TestCase
    INSERT_SQL  = "INSERT INTO TEST_TABLE VALUES(?, ?, ?, ?, ?, ?)"
    
    def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
       if File::exist?(DB_FILE)
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
@@ -42,6 +43,7 @@ class SQLTest < Test::Unit::TestCase
       if File::exist?(DB_FILE)
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
+      puts "#{self.class.name} finished." if TEST_LOGGING
    end
    
    def test01
@@ -140,6 +142,7 @@ class SQLTest < Test::Unit::TestCase
             total = total + 1
          end
          assert(total == 20)
+         r.close
       end
       
       a = []

data/test/SQLTypeTest.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class SQLTypeTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}sql_type_test.fdb"
+
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      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)
+      @connection = @database.connect(DB_USER_NAME, DB_PASSWORD)
+
+      @connection.start_transaction do |tx|
+         tx.execute("create table all_types (col01 bigint, col02 blob, "\
+                    "col03 char(100), col04 date, col05 decimal(5,2), "\
+                    "col06 double precision, col07 float, col08 integer, "\
+                    "col09 numeric(10,3), col10 smallint, col11 time, "\
+                    "col12 timestamp, col13 varchar(23))")
+      end
+   end
+
+   def teardown
+      @connection.close if @connection != nil && @connection.open?
+
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+
+   def test01
+      types = []
+      types.push(SQLType.new(SQLType::BIGINT))
+      types.push(SQLType.new(SQLType::VARCHAR, 1000))
+      types.push(SQLType.new(SQLType::DECIMAL, nil, 10))
+      types.push(SQLType.new(SQLType::NUMERIC, nil, 5, 3))
+      types.push(SQLType.new(SQLType::BLOB, nil, nil, nil, 1))
+
+      assert(types[0] == types[0])
+      assert(!(types[0] == types[1]))
+      assert(types[1] == SQLType.new(SQLType::VARCHAR, 1000))
+
+      assert(types[0].type      == SQLType::BIGINT)
+      assert(types[0].length    == nil)
+      assert(types[0].precision == nil)
+      assert(types[0].scale     == nil)
+      assert(types[0].subtype   == nil)
+
+      assert(types[1].type      == SQLType::VARCHAR)
+      assert(types[1].length    == 1000)
+      assert(types[1].precision == nil)
+      assert(types[1].scale     == nil)
+      assert(types[1].subtype   == nil)
+
+      assert(types[2].type      == SQLType::DECIMAL)
+      assert(types[2].length    == nil)
+      assert(types[2].precision == 10)
+      assert(types[2].scale     == nil)
+      assert(types[2].subtype   == nil)
+
+      assert(types[3].type      == SQLType::NUMERIC)
+      assert(types[3].length    == nil)
+      assert(types[3].precision == 5)
+      assert(types[3].scale     == 3)
+      assert(types[3].subtype   == nil)
+
+      assert(types[4].type      == SQLType::BLOB)
+      assert(types[4].length    == nil)
+      assert(types[4].precision == nil)
+      assert(types[4].scale     == nil)
+      assert(types[4].subtype   == 1)
+   end
+
+   def test02
+      types = SQLType.for_table("all_types", @connection)
+
+      assert(types['COL01'] == SQLType.new(SQLType::BIGINT))
+      assert(types['COL02'] == SQLType.new(SQLType::BLOB, nil, nil, nil, 0))
+      assert(types['COL03'] == SQLType.new(SQLType::CHAR, 100))
+      assert(types['COL04'] == SQLType.new(SQLType::DATE))
+      assert(types['COL05'] == SQLType.new(SQLType::DECIMAL, nil, 5, 2))
+      assert(types['COL06'] == SQLType.new(SQLType::DOUBLE))
+      assert(types['COL07'] == SQLType.new(SQLType::FLOAT))
+      assert(types['COL08'] == SQLType.new(SQLType::INTEGER))
+      assert(types['COL09'] == SQLType.new(SQLType::NUMERIC, nil, 10, 3))
+      assert(types['COL10'] == SQLType.new(SQLType::SMALLINT))
+      assert(types['COL11'] == SQLType.new(SQLType::TIME))
+      assert(types['COL12'] == SQLType.new(SQLType::TIMESTAMP))
+      assert(types['COL13'] == SQLType.new(SQLType::VARCHAR, 23))
+   end
+end

data/test/ServiceManagerTest.rb

@@ -3,11 +3,19 @@
 require 'TestSetup'
 require 'test/unit'
 require 'rubygems'
-require_gem 'fireruby'
+require 'fireruby'
 
 include FireRuby
 
 class ServiceManagerTest < Test::Unit::TestCase
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+   end
+   
+   def teardown
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
    def test01
       sm = ServiceManager.new('localhost')
       assert(sm.connected? == false)
@@ -18,4 +26,4 @@ class ServiceManagerTest < Test::Unit::TestCase
       assert(sm.disconnect == sm)
       assert(sm.connected? == false)
    end
-end
+end

data/test/StatementTest.rb

@@ -3,7 +3,7 @@
 require 'TestSetup'
 require 'test/unit'
 require 'rubygems'
-require_gem 'fireruby'
+require 'fireruby'
 
 include FireRuby
 
@@ -12,6 +12,7 @@ class StatementTest < Test::Unit::TestCase
    DB_FILE = "#{CURDIR}#{File::SEPARATOR}stmt_unit_test.fdb"
    
    def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
       if File::exist?(DB_FILE)
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
@@ -32,6 +33,7 @@ class StatementTest < Test::Unit::TestCase
       if File::exist?(DB_FILE)
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
+      puts "#{self.class.name} finished." if TEST_LOGGING
    end
    
    def test01
@@ -47,6 +49,7 @@ class StatementTest < Test::Unit::TestCase
       assert(s1.transaction == @transactions[0])
       assert(s1.dialect == 3)
       assert(s1.type == Statement::SELECT_STATEMENT)
+      s1.close
       
       s2 = Statement.new(@connections[0],
                          @transactions[0],
@@ -57,6 +60,7 @@ class StatementTest < Test::Unit::TestCase
       assert(s2.transaction == @transactions[0])
       assert(s2.dialect == 1)
       assert(s2.type == Statement::DELETE_STATEMENT)
+      s2.close
    end
    
    def test02
@@ -68,7 +72,8 @@ class StatementTest < Test::Unit::TestCase
                         "WHERE RDB$FIELD_NAME LIKE ?", 3)
 
       begin
-         s.execute
+         r = s.execute
+         r.close
          assert(false,
                 "Executed statement that required parameter without the "\
                 "parameter being specified.")
@@ -76,7 +81,8 @@ class StatementTest < Test::Unit::TestCase
       end
       
       begin
-         s.execute_for([])
+         r = s.execute_for([])
+         r.close
          assert(false,
                 "Executed statement that required a parameter with an empty "\
                 "parameter set.")
@@ -84,20 +90,25 @@ class StatementTest < Test::Unit::TestCase
       end
       
       begin
-         s.execute_for(['LALALA', 25])
+         r = s.execute_for(['LALALA', 25])
+         r.close
          assert(false,
                 "Executed statement that required a parameter with too many "\
                 "parameters.")
       rescue Exception => error
       end
       
-      assert(s.execute_for(['LALALA']) != nil)
-      assert(s.execute_for(['LALALA']).class == ResultSet)
+      r = s.execute_for(['LALALA'])
+      assert(r != nil)
+      assert(r.class == ResultSet)
+      r.close
+      
       total = 0
       s.execute_for(["%"]) do |row|
          total = total + 1
       end
       assert(total = 88)
+      s.close
    end
    
    def test03
@@ -105,7 +116,7 @@ class StatementTest < Test::Unit::TestCase
       @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
          cxn.execute_immediate('CREATE TABLE STRING_TEST(TEXT VARCHAR(10))')
          cxn.start_transaction do |tx|
-            # Perform an trancated insert.
+            # Perform an truncated insert.
             s = Statement.new(cxn, tx, 'INSERT INTO STRING_TEST VALUES(?)', 3)
             s.execute_for(['012345678901234'])
             

data/test/TestSetup.rb

@@ -8,3 +8,4 @@ $:.push("#{basedir}#{File::SEPARATOR}lib")
 
 DB_USER_NAME = 'sysdba'
 DB_PASSWORD  = 'masterkey'
+TEST_LOGGING = false

data/test/TransactionTest.rb

@@ -3,7 +3,7 @@
 require 'TestSetup'
 require 'test/unit'
 require 'rubygems'
-require_gem 'fireruby'
+require 'fireruby'
 
 include FireRuby
 
@@ -12,6 +12,7 @@ class TransactionTest < Test::Unit::TestCase
    DB_FILE = "#{CURDIR}#{File::SEPARATOR}tx_unit_test.fdb"
    
    def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
       if File::exist?(DB_FILE)
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
@@ -36,6 +37,7 @@ class TransactionTest < Test::Unit::TestCase
       if File::exist?(DB_FILE)
          Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
       end
+      puts "#{self.class.name} finished." if TEST_LOGGING
    end
    
    def test01
@@ -99,6 +101,7 @@ class TransactionTest < Test::Unit::TestCase
       r = @transactions[0].execute(sql[1])
       assert(r != nil)
       assert(r.class == ResultSet)
+      r.close
       
       total = 0
       @transactions[0].execute(sql[1]) do |row|

data/test/TypeTest.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+require 'date'
+
+include FireRuby
+
+class TypeTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}types_unit_test.fdb"
+   
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      if File.exist?(DB_FILE)
+         db = Database.new(DB_FILE)
+         db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      @db  = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      cxn = @db.connect(DB_USER_NAME, DB_PASSWORD)
+      cxn.start_transaction do |tx|
+         tx.execute("create table types_table (COL01 integer, "\
+                    "COL02 float, COL03 decimal(10,2), "\
+                    "COL04 numeric(5,3), COL05 date, COL06 timestamp, "\
+                    "COL07 char(10), COL08 time, COL09 varchar(30))")
+      end
+         
+      cxn.start_transaction do |tx|
+         stmt = Statement.new(cxn, tx, "insert into types_table values "\
+                                       "(?, ?, ?, ?, ?, ?, ?, ?, ?)", 3)
+         stmt.execute_for([10, 100.2, 2378.65, 192.345,
+                           Date.new(2005, 10, 21), Time.new, 'La la la',
+                           Time.new, "Oobly Joobly"])
+         stmt.close
+      end
+      cxn.close
+   end
+   
+   def teardown
+      if File::exist?(DB_FILE)
+         @db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+
+   def test01
+      rows = cxn = nil
+      begin
+         cxn = @db.connect(DB_USER_NAME, DB_PASSWORD)
+         rows = cxn.execute_immediate('select * from types_table')
+         row  = rows.fetch
+         assert(row[0].kind_of?(Integer))
+         assert(row[1].instance_of?(Float))
+         assert(row[2].instance_of?(Float))
+         assert(row[3].instance_of?(Float))
+         assert(row[4].instance_of?(Date))
+         assert(row[5].instance_of?(Time))
+         assert(row[6].instance_of?(String))
+         assert(row[7].instance_of?(Time))
+         assert(row[8].instance_of?(String))
+      ensure
+         rows.close if rows != nil
+         cxn.close if cxn != nil
+      end
+   end
+
+   def test02
+      $FireRubySettings[:DATE_AS_DATE] = false
+      rows = cxn = nil
+      begin
+         cxn = @db.connect(DB_USER_NAME, DB_PASSWORD)
+         rows = cxn.execute_immediate('select * from types_table')
+         row  = rows.fetch
+         assert(row[0].kind_of?(Integer))
+         assert(row[1].instance_of?(Float))
+         assert(row[2].instance_of?(Float))
+         assert(row[3].instance_of?(Float))
+         assert(row[4].instance_of?(Time))
+         assert(row[5].instance_of?(Time))
+         assert(row[6].instance_of?(String))
+         assert(row[7].instance_of?(Time))
+         assert(row[8].instance_of?(String))
+         rows.close
+      ensure
+         rows.close if rows != nil
+         cxn.close if cxn != nil
+      end
+      $FireRubySettings[:DATE_AS_DATE] = true
+   end
+end

data/test/UnitTest.rb

@@ -1,18 +1,64 @@
 #!/usr/bin/env ruby
 
-require 'DatabaseTest'
-require 'ConnectionTest'
-require 'TransactionTest'
-require 'StatementTest'
-require 'ResultSetTest'
-require 'RowCountTest'
-require 'RowTest'
-require 'GeneratorTest'
-require 'DDLTest'
-require 'SQLTest'
-require 'ServiceManagerTest'
-require 'CharacterSetTest'
-if PLATFORM.include?('powerpc-darwin') == false
-   require 'BackupRestoreTest'
-   require 'AddRemoveUserTest'
+#-------------------------------------------------------------------------------
+# Old Unit Test Suite
+#
+# This code has been dropped for two reasons. First, adding new tests requires
+# that this code be updated. Second, running the tests in a single Ruby
+# interpreter seems to cause issues as the tests create, use and drop a lot of
+# database files and this seems to cause intermittent problems with one or more
+# of the test scripts that doesn't occur when the script is run on its own.
+# Changing the number of scripts run also seemed to cause the problems to go
+# away. It didn't seem to matter which scripts where left out which leads me
+# to believe that the problem is related to timing issues.
+#
+# The new unit test suite, below, searches the directory for unit test files
+# and executes each in their own interpreter. I have left this code here for
+# reference purposes.
+#-------------------------------------------------------------------------------
+#require 'DatabaseTest'
+#require 'ConnectionTest'
+#require 'TransactionTest'
+#require 'StatementTest'
+#require 'ResultSetTest'
+#require 'RowCountTest'
+#require 'RowTest'
+#require 'GeneratorTest'
+#require 'DDLTest'
+#require 'SQLTest'
+#require 'ServiceManagerTest'
+#require 'CharacterSetTest'
+#require 'KeyTest'
+#require 'TypeTest'
+#require 'SQLTypeTest'
+#if PLATFORM.include?('powerpc-darwin') == false
+#   require 'BackupRestoreTest'
+#   require 'AddRemoveUserTest'
+#end
+#-------------------------------------------------------------------------------
+SPECIALS = ['AddRemoveUserTest',
+            'BackupRestoreTest',
+            'ServiceManagerTest']
+begin
+   files = Dir.entries(".")
+   files.reject! do |name|
+                    ['.', '..', 'UnitTest.rb'].include?(name) or
+                    name[-7,7] != 'Test.rb'
+                 end
+   files.each do |name|
+      execute = true
+      if SPECIALS.include?(name)
+         execute = !(PLATFORM.include?('powerpc-darwin'))
+      end
+      
+      if execute
+         system("ruby #{name}")
+         
+         if $? != 0
+            raise StandardError.new("Error executing '#{name}'. Testing terminated.")
+         end
+      end
+   end
+rescue => error
+   puts "\n\nERROR: #{error.message}"
 end