ibruby 0.5.5-i686-darwin8.9.1

data/test/RowTest.rb

@@ -0,0 +1,205 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class RowTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}row_unit_test.ib"
+   
+   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)
+      @transaction = @connection.start_transaction
+      @results     = ResultSet.new(@connection, @transaction,
+                                   'SELECT * FROM RDB$FIELDS', 3, nil)
+      @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 boolean, 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([false, 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
+      @results.close
+      @transaction.rollback
+      @connection.close
+      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
+      row = Row.new(@results, @empty, 100)
+      
+      assert(row.column_count == 28)
+      assert(row.number == 100)
+      assert(row.column_name(0) == 'RDB$FIELD_NAME')
+      assert(row.column_alias(10) == 'RDB$FIELD_TYPE')
+      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(['ONE', 'TWO', 'THREE'].include?(name))
+         assert([1, 'Two', 3].include?(value))
+         count += 1
+      end
+      assert(count == 3)
+      
+      count = 0
+      data.each_key do |name|
+         assert(['ONE', 'TWO', 'THREE'].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('TWO') == 'Two')
+      assert(data.fetch('FOUR', 'LALALA') == 'LALALA')
+      assert(data.fetch('ZERO') {'NOT FOUND'} == 'NOT FOUND')
+      begin
+         data.fetch('FIVE')
+         assert(false, 'Row#fetch succeeded for non-existent column name.')
+      rescue IndexError
+      end
+      
+      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)
+      
+      assert(data.has_value?(3))
+      assert(data.has_value?('LALALA') == false)
+      
+      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
+
+      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 == 'TWO'}
+      assert(array.size == 1)
+      assert(array[0][0] == 'TWO')
+      assert(array[0][1] == 'Two')
+      
+      array = data.to_a
+      assert(array.size == 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['ONE'] == 1)
+      assert(hash['TWO'] == 'Two')
+      assert(hash['THREE'] == 3)
+      
+      array = data.values_at('TEN', 'TWO', 'THREE')
+      assert(array.size == 3)
+      assert(array.include?('Two'))
+      assert(array.include?(3))
+      assert(array.include?(nil))
+      
+      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::BOOLEAN)
+         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

@@ -0,0 +1,182 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class SQLTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}sql_unit_test.ib"
+   ITERATIONS  = 100
+   
+   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
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @connections  = []
+      @transactions = []
+      
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('CREATE TABLE TEST_TABLE (TESTID INTEGER '\
+                               'NOT NULL PRIMARY KEY, TESTTEXT VARCHAR(100), '\
+                               'TESTFLOAT NUMERIC(8,2), TESTDATE DATE, TESTTIME '\
+                               'TIME, TESTSTAMP TIMESTAMP)')
+      end
+   end
+   
+   def teardown
+      @transactions.each do |tx|
+         tx.rollback if tx.active?
+      end
+      
+      @connections.each do |cxn|
+         cxn.close if cxn.open?
+      end
+      
+      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
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.start_transaction do |tx|
+            s = Statement.new(cxn, tx, INSERT_SQL, 3)
+            f = 0.0
+            t = Time.new
+            
+            1.upto(ITERATIONS) do |i|
+               f += 0.321
+               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))
+      @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
+      f = 0.0
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         1.upto(20) do |i|
+            f += i
+            sql = "INSERT INTO TEST_TABLE VALUES (#{i}, "\
+                  "#{f.to_s}, #{f}, NULL, NULL, 'NOW')"
+            cxn.execute_immediate(sql)
+         end
+      end
+      
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      @transactions.push(@connections[0].start_transaction)
+      r = @transactions[0].execute("SELECT COUNT(*) FROM TEST_TABLE")
+      assert(r.fetch[0] == 20)
+      r.close
+      
+      r = @transactions[0].execute("SELECT * FROM TEST_TABLE WHERE TESTID IN "\
+                                   "(2, 4, 6, 8, 10) ORDER BY TESTID ASCENDING")
+      a = r.fetch
+      assert(a[0] == 2)
+      assert(a[1] == '3.0')
+      assert(a[2] == 3.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+
+      a = r.fetch
+      assert(a[0] == 4)
+      assert(a[1] == '10.0')
+      assert(a[2] == 10.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+
+      a = r.fetch
+      assert(a[0] == 6)
+      assert(a[1] == '21.0')
+      assert(a[2] == 21.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+
+      a = r.fetch
+      assert(a[0] == 8)
+      assert(a[1] == '36.0')
+      assert(a[2] == 36.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+
+      a = r.fetch
+      assert(a[0] == 10)
+      assert(a[1] == '55.0')
+      assert(a[2] == 55.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+      
+      r.close
+      
+      @transactions[0].commit
+      
+      @connections[0].start_transaction do |tx|
+         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
+         r.each do |row|
+            assert(row[0] == nil)
+            total = total + 1
+         end
+         assert(total == 20)
+         r.close
+      end
+      
+      a = []
+      t = nil
+      @connections[0].start_transaction do |tx|
+         # Perform an insert via a parameterized statement.
+         s = Statement.new(@connections[0], tx,
+                           "INSERT INTO TEST_TABLE (TESTID, TESTTEXT, "\
+                           "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 "\
+                        "TEST_TABLE WHERE TESTID = 25000")
+         a = r.fetch
+         r.close
+      end
+      assert(a[0] == 'La la la')
+      assert(a[1] == 3.14)
+      assert(a[2].to_i == t.to_i)
+      
+      @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|
+         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
+end
+

data/test/SQLTypeTest.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class SQLTypeTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}sql_type_test.ib"
+
+   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 boolean, 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::BOOLEAN))
+      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::BOOLEAN)
+      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::BOOLEAN))
+      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/SQLTypeTest.rb.rej

@@ -0,0 +1,17 @@
+***************
+*** 9,15 ****
+  
+  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
+--- 9,15 ----
+  
+  class SQLTypeTest < Test::Unit::TestCase
+     CURDIR  = "#{Dir.getwd}"
++    DB_FILE = "#{CURDIR}#{File::SEPARATOR}sql_type_test.ib"
+  
+     def setup
+        puts "#{self.class.name} started." if TEST_LOGGING

data/test/ServiceManagerTest.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+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)
+
+      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

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class StatementTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}stmt_unit_test.ib"
+   
+   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 = []
+   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
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      @transactions.push(@connections.last.start_transaction)
+      
+      s1 = Statement.new(@connections[0],
+                         @transactions[0],
+                         "SELECT RDB$FIELD_NAME FROM RDB$FIELDS", 3)
+      assert(s1 != nil)
+      assert(s1.sql == "SELECT RDB$FIELD_NAME FROM RDB$FIELDS")
+      assert(s1.connection == @connections[0])
+      assert(s1.transaction == @transactions[0])
+      assert(s1.dialect == 3)
+      assert(s1.type == Statement::SELECT_STATEMENT)
+      s1.close
+      
+      s2 = Statement.new(@connections[0],
+                         @transactions[0],
+                         "DELETE FROM RDB$EXCEPTIONS", 1)
+      assert(s2 != nil)
+      assert(s2.sql == "DELETE FROM RDB$EXCEPTIONS")
+      assert(s2.connection == @connections[0])
+      assert(s2.transaction == @transactions[0])
+      assert(s2.dialect == 1)
+      assert(s2.type == Statement::DELETE_STATEMENT)
+      s2.close
+   end
+   
+   def test02
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      @transactions.push(@connections[0].start_transaction)
+      
+      s = Statement.new(@connections[0], @transactions[0],
+                        "SELECT RDB$FIELD_NAME FROM RDB$FIELDS "\
+                        "WHERE RDB$FIELD_NAME LIKE ?", 3)
+
+      begin
+         r = s.execute
+         r.close
+         assert(false,
+                "Executed statement that required parameter without the "\
+                "parameter being specified.")
+      rescue Exception => error
+      end
+      
+      begin
+         r = s.execute_for([])
+         r.close
+         assert(false,
+                "Executed statement that required a parameter with an empty "\
+                "parameter set.")
+      rescue Exception => error
+      end
+      
+      begin
+         r = s.execute_for(['LALALA', 25])
+         r.close
+         assert(false,
+                "Executed statement that required a parameter with too many "\
+                "parameters.")
+      rescue Exception => error
+      end
+      
+      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
+      d = nil
+      @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 truncated insert.
+            s = Statement.new(cxn, tx, 'INSERT INTO STRING_TEST VALUES(?)', 3)
+            s.execute_for(['012345678901234'])
+            
+            # Perform a select of the value inserted.
+            r = cxn.execute('SELECT * FROM STRING_TEST', tx)
+            d = r.fetch
+            
+            # Clean up.
+            s.close
+            r.close
+         end
+         assert(d[0] == '0123456789')
+         cxn.execute_immediate('DROP TABLE STRING_TEST')
+      end
+   end
+end

data/test/StatementTest.rb.rej

@@ -0,0 +1,17 @@
+***************
+*** 9,15 ****
+  
+  class StatementTest < Test::Unit::TestCase
+     CURDIR  = "#{Dir.getwd}"
+-    DB_FILE = "#{CURDIR}#{File::SEPARATOR}stmt_unit_test.fdb"
+     
+     def setup
+        puts "#{self.class.name} started." if TEST_LOGGING
+--- 9,15 ----
+  
+  class StatementTest < Test::Unit::TestCase
+     CURDIR  = "#{Dir.getwd}"
++    DB_FILE = "#{CURDIR}#{File::SEPARATOR}stmt_unit_test.ib"
+     
+     def setup
+        puts "#{self.class.name} started." if TEST_LOGGING

data/test/TestSetup.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+# Add extra search paths.
+basedir = File::dirname(Dir.getwd)
+$:.push(basedir)
+$:.push("#{basedir}#{File::SEPARATOR}test")
+$:.push("#{basedir}#{File::SEPARATOR}lib")
+
+DB_USER_NAME = 'sysdba'
+DB_PASSWORD  = 'masterkey'
+TEST_LOGGING = true