fireruby 0.4.1-i586-linux → 0.4.2-i586-linux

data/test/GeneratorTest.rb

@@ -1,50 +1,50 @@
-#!/usr/bin/env ruby
-
-require 'TestSetup'
-require 'test/unit'
-require 'rubygems'
-require 'fireruby'
-
-include FireRuby
-
-class GeneratorTest < Test::Unit::TestCase
-   CURDIR  = "#{Dir.getwd}"
-   DB_FILE = "#{CURDIR}#{File::SEPARATOR}generator_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
-      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
-      @connections  = []
-      
-      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
-   end
-   
-   def teardown
-      @connections.each do |cxn|
-         cxn.close if cxn.open?
-      end
-      @connections.clear
-      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
-      assert(Generator::exists?('TEST_GEN', @connections[0]) == false)
-      g = Generator::create('TEST_GEN', @connections[0])
-      assert(Generator::exists?('TEST_GEN', @connections[0]))
-      assert(g.last == 0)
-      assert(g.next(1) == 1)
-      assert(g.last == 1)
-      assert(g.next(10) == 11)
-      assert(g.connection == @connections[0])
-      assert(g.name == 'TEST_GEN')
-      
-      g.drop
-      assert(Generator::exists?('TEST_GEN', @connections[0]) == false)
-   end
-end
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class GeneratorTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}generator_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
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @connections  = []
+      
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+   end
+   
+   def teardown
+      @connections.each do |cxn|
+         cxn.close if cxn.open?
+      end
+      @connections.clear
+      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
+      assert(Generator::exists?('TEST_GEN', @connections[0]) == false)
+      g = Generator::create('TEST_GEN', @connections[0])
+      assert(Generator::exists?('TEST_GEN', @connections[0]))
+      assert(g.last == 0)
+      assert(g.next(1) == 1)
+      assert(g.last == 1)
+      assert(g.next(10) == 11)
+      assert(g.connection == @connections[0])
+      assert(g.name == 'TEST_GEN')
+      
+      g.drop
+      assert(Generator::exists?('TEST_GEN', @connections[0]) == false)
+   end
+end

data/test/KeyTest.rb

@@ -1,140 +1,140 @@
-#!/usr/bin/env ruby
-
-require 'TestSetup'
-require 'test/unit'
-require 'rubygems'
-require 'fireruby'
-
-include FireRuby
-
-class KeyTest < Test::Unit::TestCase
-   CURDIR  = "#{Dir.getwd}"
-   DB_FILE = "#{CURDIR}#{File::SEPARATOR}key_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
-      
-      # Switch to the old way of keying.
-      $FireRubySettings[:ALIAS_KEYS] = false
-      
-      database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
-      @connection  = database.connect(DB_USER_NAME, DB_PASSWORD)
-      @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 keytest (COL01 integer, '\
-                                    'COL02 varchar(10), COL03 integer)')
-      @connection.execute_immediate("insert into keytest values (1, 'Two', 3)")
-   end
-   
-   def teardown
-      @results.close
-      @transaction.rollback
-      @connection.close
-      if File::exist?(DB_FILE)
-         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
-      end
-      $FireRubySettings[:ALIAS_KEYS] = true
-      puts "#{self.class.name} finished." if TEST_LOGGING
-   end
-   
-   def test_01
-      sql  = 'select COL01 one, COL02 two, COL03 three from keytest'
-      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_column?('COL02'))
-      assert(data.has_column?('COL22') == 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.names.size == 3)
-      data.names.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
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class KeyTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}key_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
+      
+      # Switch to the old way of keying.
+      $FireRubySettings[:ALIAS_KEYS] = false
+      
+      database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @connection  = database.connect(DB_USER_NAME, DB_PASSWORD)
+      @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 keytest (COL01 integer, '\
+                                    'COL02 varchar(10), COL03 integer)')
+      @connection.execute_immediate("insert into keytest values (1, 'Two', 3)")
+   end
+   
+   def teardown
+      @results.close
+      @transaction.rollback
+      @connection.close
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      $FireRubySettings[:ALIAS_KEYS] = true
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   def test_01
+      sql  = 'select COL01 one, COL02 two, COL03 three from keytest'
+      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_column?('COL02'))
+      assert(data.has_column?('COL22') == 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.names.size == 3)
+      data.names.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/ResultSetTest.rb

@@ -1,162 +1,162 @@
-#!/usr/bin/env ruby
-
-require 'TestSetup'
-require 'test/unit'
-require 'rubygems'
-require 'fireruby'
-
-include FireRuby
-
-class ResultSetTest < Test::Unit::TestCase
-   CURDIR  = "#{Dir.getwd}"
-   DB_FILE = "#{CURDIR}#{File::SEPARATOR}result_set_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
-      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
-      @connections  = []
-      @transactions = []
-      
-      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
-      
-      @connections[0].start_transaction do |tx|
-         tx.execute("CREATE TABLE TEST_TABLE (TESTID INTEGER NOT NULL "\
-                    "primary KEY, TESTINFO VARCHAR(100))")
-         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
-      
-      @connections[0].start_transaction do |tx|
-         begin
-            tx.execute("INSERT INTO TEST_TABLE VALUES (10, 'Record One.')")
-            tx.execute("INSERT INTO TEST_TABLE VALUES (20, 'Record Two.')")
-            tx.execute("INSERT INTO TEST_TABLE VALUES (30, 'Record Three.')")
-            tx.execute("INSERT INTO TEST_TABLE VALUES (40, 'Record Four.')")
-            tx.execute("INSERT INTO TEST_TABLE VALUES (50, 'Record Five.')")
-         rescue Exception => error
-            puts error.message
-            error.backtrace.each {|step| puts "   #{step}"}
-            raise
-         end
-      end
-      
-      @transactions.push(@connections[0].start_transaction)
-   end
-   
-   def teardown
-      @transactions.each do |tx|
-         tx.rollback if tx.active?
-      end
-      @transactions.clear
-      @connections.each do |cxn|
-         cxn.close if cxn.open?
-      end
-      @connections.clear
-      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
-      r = ResultSet.new(@connections[0], @transactions[0],
-                        "SELECT * FROM TEST_TABLE ORDER BY TESTID", 3, nil)
-      
-      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)
-      assert(r.fetch[0] == 30)
-      assert(r.fetch[1] == 'Record Four.')
-      r.fetch
-      assert(r.fetch == nil)
-      r.close
-      
-      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')
-      assert(r.column_name(3) == nil)
-      assert(r.column_name(-1) == nil)
-      assert(r.column_table(0) == 'TEST_TABLE')
-      assert(r.column_table(1) == 'TEST_TABLE')
-      assert(r.column_table(2) == nil)
-      assert(r.column_table(-1) == nil)
-      assert(r.column_alias(0) == 'TESTID')
-      assert(r.column_alias(1) == 'TESTINFO')
-      assert(r.column_alias(3) == nil)
-      assert(r.column_alias(-1) == nil)
-      r.close
-      
-      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)
-      assert(r.exhausted?)
-   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)
-      assert(r.exhausted?)
-   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
-   
-   def test04
-      results = nil
-      begin
-         results = @transactions[0].execute('select * from all_types')
-        
-         assert(results.get_base_type(0) == SQLType::BIGINT)
-         assert(results.get_base_type(1) == SQLType::BLOB)
-         assert(results.get_base_type(2) == SQLType::CHAR)
-         assert(results.get_base_type(3) == SQLType::DATE)
-         assert(results.get_base_type(4) == SQLType::DECIMAL)
-         assert(results.get_base_type(5) == SQLType::DOUBLE)
-         assert(results.get_base_type(6) == SQLType::FLOAT)
-         assert(results.get_base_type(7) == SQLType::INTEGER)
-         assert(results.get_base_type(8) == SQLType::NUMERIC)
-         assert(results.get_base_type(9) == SQLType::SMALLINT)
-         assert(results.get_base_type(10) == SQLType::TIME)
-         assert(results.get_base_type(11) == SQLType::TIMESTAMP)
-         assert(results.get_base_type(12) == SQLType::VARCHAR)
-      ensure
-         results.close if results != nil
-      end
-   end
-end
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class ResultSetTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}result_set_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
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @connections  = []
+      @transactions = []
+      
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      
+      @connections[0].start_transaction do |tx|
+         tx.execute("CREATE TABLE TEST_TABLE (TESTID INTEGER NOT NULL "\
+                    "primary KEY, TESTINFO VARCHAR(100))")
+         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
+      
+      @connections[0].start_transaction do |tx|
+         begin
+            tx.execute("INSERT INTO TEST_TABLE VALUES (10, 'Record One.')")
+            tx.execute("INSERT INTO TEST_TABLE VALUES (20, 'Record Two.')")
+            tx.execute("INSERT INTO TEST_TABLE VALUES (30, 'Record Three.')")
+            tx.execute("INSERT INTO TEST_TABLE VALUES (40, 'Record Four.')")
+            tx.execute("INSERT INTO TEST_TABLE VALUES (50, 'Record Five.')")
+         rescue Exception => error
+            puts error.message
+            error.backtrace.each {|step| puts "   #{step}"}
+            raise
+         end
+      end
+      
+      @transactions.push(@connections[0].start_transaction)
+   end
+   
+   def teardown
+      @transactions.each do |tx|
+         tx.rollback if tx.active?
+      end
+      @transactions.clear
+      @connections.each do |cxn|
+         cxn.close if cxn.open?
+      end
+      @connections.clear
+      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
+      r = ResultSet.new(@connections[0], @transactions[0],
+                        "SELECT * FROM TEST_TABLE ORDER BY TESTID", 3, nil)
+      
+      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)
+      assert(r.fetch[0] == 30)
+      assert(r.fetch[1] == 'Record Four.')
+      r.fetch
+      assert(r.fetch == nil)
+      r.close
+      
+      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')
+      assert(r.column_name(3) == nil)
+      assert(r.column_name(-1) == nil)
+      assert(r.column_table(0) == 'TEST_TABLE')
+      assert(r.column_table(1) == 'TEST_TABLE')
+      assert(r.column_table(2) == nil)
+      assert(r.column_table(-1) == nil)
+      assert(r.column_alias(0) == 'TESTID')
+      assert(r.column_alias(1) == 'TESTINFO')
+      assert(r.column_alias(3) == nil)
+      assert(r.column_alias(-1) == nil)
+      r.close
+      
+      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)
+      assert(r.exhausted?)
+   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)
+      assert(r.exhausted?)
+   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
+   
+   def test04
+      results = nil
+      begin
+         results = @transactions[0].execute('select * from all_types')
+        
+         assert(results.get_base_type(0) == SQLType::BIGINT)
+         assert(results.get_base_type(1) == SQLType::BLOB)
+         assert(results.get_base_type(2) == SQLType::CHAR)
+         assert(results.get_base_type(3) == SQLType::DATE)
+         assert(results.get_base_type(4) == SQLType::DECIMAL)
+         assert(results.get_base_type(5) == SQLType::DOUBLE)
+         assert(results.get_base_type(6) == SQLType::FLOAT)
+         assert(results.get_base_type(7) == SQLType::INTEGER)
+         assert(results.get_base_type(8) == SQLType::NUMERIC)
+         assert(results.get_base_type(9) == SQLType::SMALLINT)
+         assert(results.get_base_type(10) == SQLType::TIME)
+         assert(results.get_base_type(11) == SQLType::TIMESTAMP)
+         assert(results.get_base_type(12) == SQLType::VARCHAR)
+      ensure
+         results.close if results != nil
+      end
+   end
+end