ruby-oci8 2.2.5.1-x86-mingw32 → 2.2.9-x86-mingw32

data/ruby-oci8.gemspec

@@ -34,7 +34,6 @@ spec = Gem::Specification.new do |s|
   s.description = <<EOS
 ruby-oci8 is a ruby interface for Oracle using OCI8 API. It is available with Oracle 10g or later including Oracle Instant Client.
 EOS
-  s.has_rdoc = 'yard'
   s.authors = ['Kubo Takehiro']
   s.platform = gem_platform
   s.license = 'BSD-2-Clause'
@@ -79,7 +78,7 @@ EOS
     end
     files << 'lib/oci8.rb'
   end
-  s.require_paths = ['lib', 'ext/oci8']
+  s.require_paths = ['lib']
   s.files = files
   s.test_files = 'test/test_all.rb'
   s.extra_rdoc_files = ['README.md']

data/setup.rb

@@ -189,7 +189,16 @@ class ConfigTable
                      'the make program to compile ruby extentions' ] ],
     [ 'without-ext', [ 'no',
                        'yes/no',
-                       'does not compile/install ruby extentions' ] ]
+                       'does not compile/install ruby extentions' ] ],
+    [ 'with-instant-client-dir', ['',
+                                  'path',
+                                  'path to the Oracle instant client directory'] ],
+    [ 'with-instant-client-lib', ['',
+                                  'path',
+                                  'path to the Oracle instant client libraries'] ],
+    [ 'with-instant-client-include', ['',
+                                      'path',
+                                      'path to the Oracle instant client header files'] ]
   ]
   multipackage_descripters = [
     [ 'with',      [ '',
@@ -277,7 +286,7 @@ class ConfigTable
 
   def initialize_from_table
     @table = {}
-    DESCRIPTER.each do |k, (default, vname, desc, default2)|
+    DESCRIPTER.each do |k, (default, *)|
       @table[k] = default
     end
   end

data/test/README.md

@@ -0,0 +1,37 @@
+Before running unit test:
+
+1. Connect to Oracle as sys
+   ```shell
+   $ sqlplus sys/<password_of_sys> as sysdba
+   SQL>
+   ```
+2. Create user ruby
+   ```sql
+   SQL> CREATE USER ruby IDENTIFIED BY oci8 DEFAULT TABLESPACE users TEMPORARY TABLESPACE temp;
+   SQL> alter user ruby quota unlimited on users;
+   ```
+3. Grant the privilege to connect and execute.
+   ```sql
+    SQL> GRANT connect, resource, create view, create synonym TO ruby;
+    SQL> GRANT execute ON dbms_lock TO ruby;
+    ```
+4. Connect as ruby user.
+   ```shell
+   $ sqlplus ruby/oci8
+   SQL>
+   ```
+5. Create object types
+   ```sql
+   SQL> @test/setup_test_object.sql
+   SQL> @test/setup_test_package.sql
+   ```
+6. change $dbname in test/config.rb.
+
+Then run the following command:
+```shell
+$ make check
+```
+or
+```
+$ nmake check   (If your compiler is MS Visual C++.)
+````

data/test/config.rb

@@ -134,7 +134,7 @@ class Minitest::Test
 
   def get_oci8_connection()
     OCI8.new($dbuser, $dbpass, $dbname)
-      rescue OCIError
+  rescue OCIError
     raise if $!.code != 12516 && $!.code != 12520
     # sleep a few second and try again if
     # the error code is ORA-12516 or ORA-12520.

data/test/setup_test_object.sql

@@ -61,6 +61,8 @@ create type rb_test_obj as object (
   obj_array_val rb_test_obj_elem_array,
   obj_ary_of_ary_val rb_test_obj_elem_ary_of_ary,
   date_val date,
+  timestamp_val timestamp(9),
+  timestamp_tz_val timestamp(9) with time zone,
 --  date_array_val rb_test_date_array,
 
   constructor function rb_test_obj(n number) return self as result,
@@ -72,19 +74,23 @@ create type rb_test_obj as object (
   member procedure member_proc(n in integer)
 )
 /
-create or replace type body rb_test_obj is
-
+create type body rb_test_obj is
   constructor function rb_test_obj(n number) return self as result is
-    function to_test_date(n number) return date is
-    begin
-      return to_date(to_char(1990 + n, 'FM0000') ||
-                     to_char(mod(round(n) * 5, 12) + 1, 'FM00') ||
-                     to_char(mod(round(n) * 7, 27) + 1, 'FM00') ||
-                     to_char(mod(round(n) * 9, 24), 'FM00') ||
-                     to_char(mod(round(n) * 11, 60), 'FM00') ||
-                     to_char(mod(round(n) * 13, 60), 'FM00'), 'yyyymmddhh24miss');
-    end;
+    str varchar(28);
+    ts timestamp(9);
+    ts_tz timestamp(9) with time zone;
   begin
+    str := to_char(1990 + n, 'FM0000') ||
+                   to_char(mod(round(n) * 5, 12) + 1, 'FM00') ||
+                   to_char(mod(round(n) * 7, 27) + 1, 'FM00') ||
+                   to_char(mod(round(n) * 9, 24), 'FM00') ||
+                   to_char(mod(round(n) * 11, 60), 'FM00') ||
+                   to_char(mod(round(n) * 13, 60), 'FM00') ||
+                   to_char(mod(round(n) * 333333333, 1000000000), 'FM000000000');
+    ts := to_timestamp(str, 'yyyymmddhh24missff9');
+    str := str || to_char(mod(round(n) * 15, 24) - 11, 'FMS00') ||
+                  to_char(mod(round(n) * 17, 60), 'FM00');
+    ts_tz := to_timestamp_tz(str, 'yyyymmddhh24missff9tzhtzm');
     self.int_val := n;
     self.flt_val := n;
     self.num_val := n;
@@ -96,7 +102,9 @@ create or replace type body rb_test_obj is
     self.nclob_val := to_clob(n);
     self.blob_val := to_blob(utl_raw.cast_to_raw(to_char(n)));
     self.obj_val := rb_test_obj_elem(n, n + 1);
-    self.date_val := to_test_date(n);
+    self.date_val := ts;
+    self.timestamp_val := ts;
+    self.timestamp_tz_val := ts_tz;
     if self.int_val != 1 then
       self.int_array_val := rb_test_int_array(n, n + 1, n + 2);
       self.flt_array_val := rb_test_flt_array(n, n + 1, n + 2);
@@ -120,7 +128,7 @@ create or replace type body rb_test_obj is
 
   static function test_object_version return integer is
   begin
-    return 3;
+    return 4;
   end;
 
   static function class_func(n number) return rb_test_obj is

data/test/test_all.rb

@@ -26,6 +26,7 @@ require "#{srcdir}/test_oracle_version"
 require "#{srcdir}/test_error"
 require "#{srcdir}/test_connection_pool"
 require "#{srcdir}/test_object"
+require "#{srcdir}/test_properties.rb"
 
 if OCI8.respond_to? :encoding
   require "#{srcdir}/test_encoding"

data/test/test_break.rb

@@ -22,9 +22,8 @@ class TestBreak < Minitest::Test
   @@server_is_runing_on_windows = nil
   def server_is_runing_on_windows?
     if @@server_is_runing_on_windows.nil?
-      @@server_is_runing_on_windows = false
-      @conn.exec('select banner from v$version') do |row|
-        @@server_is_runing_on_windows = true if row[0].include? 'Windows'
+      @conn.exec('select dbms_utility.port_string from dual') do |row|
+        @@server_is_runing_on_windows = row[0].include? '/WIN'
       end
     end
     @@server_is_runing_on_windows
@@ -63,7 +62,7 @@ class TestBreak < Minitest::Test
     expect = []
     expect[PLSQL_DONE] = TIME_IN_PLSQL
     expect[OCIBREAK]   = "Invalid status"
-    if defined? Rubinius and Rubinius::VERSION >= "2.0"
+    if (defined? Rubinius and Rubinius::VERSION >= "2.0") || (defined? RUBY_ENGINE and RUBY_ENGINE == "truffleruby")
       # Rubinius 2.0.0.
       # DBMS_LOCK.SLEEP blocks ruby threads which try to call C-API.
       expect[SEND_BREAK] = TIME_TO_BREAK

data/test/test_clob.rb

@@ -24,22 +24,6 @@ class TestCLob < Minitest::Test
     lob.close
   end
 
-  def test_insert_with_flush
-    filename = File.basename($lobfile)
-    @conn.exec("DELETE FROM test_table WHERE filename = :1", filename)
-    @conn.exec("INSERT INTO test_table(filename, content) VALUES (:1, EMPTY_CLOB())", filename)
-    cursor = @conn.exec("SELECT content FROM test_table WHERE filename = :1 FOR UPDATE", filename)
-    lob = cursor.fetch[0]
-    lob.sync = false
-    open($lobfile) do |f|
-      while s = f.read(1000)
-        lob.write(s)
-      end
-    end
-    lob.flush
-    lob.close
-  end
-
   def test_insert_symbol
     filename = 'test_symbol'
     value = :foo_bar
@@ -76,6 +60,9 @@ class TestCLob < Minitest::Test
 
   # https://github.com/kubo/ruby-oci8/issues/20
   def test_github_issue_20
+    # Skip this test if FULLTEST isn't set because it takes 4 minutes in my Linux box.
+    return if ENV['FULLTEST']
+
     lob1 = OCI8::CLOB.new(@conn, ' '  * (1024 * 1024))
     lob1.read(1) # to suppress `warning: assigned but unused variable - lob1`
     begin

data/test/test_datetime.rb

@@ -1,6 +1,5 @@
 require 'oci8'
 require File.dirname(__FILE__) + '/config'
-require 'scanf'
 
 class TestDateTime < Minitest::Test
 
@@ -28,6 +27,12 @@ class TestDateTime < Minitest::Test
     convert_to_datetime($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, subsec, $8)
   end
 
+  # 'YYYY-MM-DD HH24:MI:SS' or 'YYYY-MM-DD HH24:MI:SS.FF6' to array
+  def string_to_array(str)
+    /(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)(?:\.(\d+))?/ =~ str
+    [$1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, $7 ? $7.to_i / 1000 : 0]
+  end
+
   def setup
     @conn = get_oci8_connection
   end
@@ -43,7 +48,7 @@ class TestDateTime < Minitest::Test
       @conn.exec(<<-EOS) do |row|
 SELECT TO_DATE('#{date}', 'YYYY-MM-DD HH24:MI:SS') FROM dual
 EOS
-        assert_equal(Time.local(*date.scanf("%d-%d-%d %d:%d:%d.%06d")), row[0])
+        assert_equal(Time.local(*string_to_array(date)), row[0])
       end
     end
   end
@@ -94,7 +99,7 @@ EOS
       @conn.exec(<<-EOS) do |row|
 SELECT TO_TIMESTAMP('#{date}', 'YYYY-MM-DD HH24:MI:SS.FF') FROM dual
 EOS
-        assert_equal(Time.local(*date.scanf("%d-%d-%d %d:%d:%d.%06d")), row[0])
+        assert_equal(Time.local(*string_to_array(date)), row[0])
       end
     end
   end

data/test/test_object.rb

@@ -1,6 +1,12 @@
 require 'oci8'
 require File.dirname(__FILE__) + '/config'
 
+class Time
+  def inspect
+    self.strftime("%Y-%m-%d %H:%M:%S.%N %:z")
+  end
+end
+
 conn = OCI8.new($dbuser, $dbpass, $dbname)
 error_message = nil
 begin
@@ -22,7 +28,7 @@ begin
 
   begin
     version = RbTestObj.test_object_version(conn)
-    error_message = "Invalid test object version" if version != 3
+    error_message = "Invalid test object version" if version != 4
   rescue NoMethodError
     raise unless $!.to_s.include?('test_object_version')
     error_message = "rb_test_obj.test_object_version is not declared."
@@ -100,7 +106,8 @@ class TestObj1 < Minitest::Test
     attr_reader :obj_array_val
     attr_reader :obj_ary_of_ary_val
     attr_reader :date_val
-#    attr_reader :date_array_val
+    attr_reader :timestamp_val
+    attr_reader :timestamp_tz_val
 
     attr_accessor :assertions
 
@@ -109,16 +116,28 @@ class TestObj1 < Minitest::Test
       @assertions = 0
     end
 
-    def to_test_date(n)
+    def to_test_datetime(n, type)
       year = (1990 + n).round
       month = (n.round * 5) % 12 + 1
       mday = (n.round * 7) % 27 + 1
       hour = (n.round * 9) % 24
       minute = (n.round * 11) % 60
       sec = (n.round * 13) % 60
-      convert_to_time(year, month, mday, hour, minute, sec, 0, nil)
+      nsec = if type == :date
+               0
+             else
+               ((n.round * 333_333_333) % 1_000_000_000).to_r / 1_000_000_000
+             end
+      tz = if type == :timestamp_tz
+             tzh = (n.round * 15) % 24 - 11
+             tzm = (n.round * 17) % 60
+             format('%+03d:%02d', tzh, tzm)
+           else
+             nil
+           end
+      convert_to_time(year, month, mday, hour, minute, sec, nsec, tz)
     end
-    private :to_test_date
+    private :to_test_datetime
 
     def next
       @n += 1.2
@@ -135,7 +154,9 @@ class TestObj1 < Minitest::Test
       @nclob_val = @str_val
       @blob_val = @str_val
       @obj_val = ExpectedValObjElem.new(@int_val, @int_val + 1)
-      @date_val = to_test_date(@n)
+      @date_val = to_test_datetime(@n, :date)
+      @timestamp_val = to_test_datetime(@n, :timestamp)
+      @timestamp_tz_val = to_test_datetime(@n, :timestamp_tz)
       if @int_val == 1
         @int_array_val = nil
         @flt_array_val = nil
@@ -199,7 +220,8 @@ class TestObj1 < Minitest::Test
         obj_array_val = val[18]
         obj_ary_of_ary_val = val[19]
         date_val = val[20]
-#        date_array_val = val[18]
+        timestamp_val = val[21]
+        timestamp_tz_val = val[22]
       else
         assert_instance_of(RbTestObj, val)
         int_val = val.int_val
@@ -223,7 +245,8 @@ class TestObj1 < Minitest::Test
         obj_array_val = val.obj_array_val
         obj_ary_of_ary_val = val.obj_ary_of_ary_val
         date_val = val.date_val
-#        date_array_val = val.date_array_val
+        timestamp_val = val.timestamp_val
+        timestamp_tz_val = val.timestamp_tz_val
       end
 
       assert_equal(@int_val, int_val)
@@ -267,7 +290,8 @@ class TestObj1 < Minitest::Test
         assert_nil(obj_ary_of_ary_val)
       end
       assert_equal(@date_val, date_val)
-#      assert_equal(@date_array_val, date_array_val && date_array_val.to_ary)
+      assert_equal(@timestamp_val, timestamp_val)
+      assert_equal(@timestamp_tz_val, timestamp_tz_val)
     end
 
     def assert_array_in_delta(exp, val)

data/test/test_oci8.rb

@@ -25,53 +25,142 @@ EOS
     drop_table('test_rename_table')
   end
 
-  # USE_DYNAMIC_FETCH doesn't work well...
-  # This test is disabled.
-  def _test_long_type
-    drop_table('test_table')
-    @conn.exec('CREATE TABLE test_table (id number(38), lng long)')
-    test_data1 = 'a' * 70000
-    test_data2 = 'b' * 3000
-    test_data3 = nil
-    test_data4 = 'c' * 70000
-    @conn.exec('insert into test_table values (:1, :2)', 1, test_data1)
-    @conn.exec('insert into test_table values (:1, :2)', 2, [test_data2, :long])
-    @conn.exec('insert into test_table values (:1, :2)', 3, [nil, :long])
-    @conn.exec('insert into test_table values (:1, :2)', 4, [test_data4, :long])
-
-    [8000, 65535, 65536, 80000].each do |read_len|
-      @conn.long_read_len = read_len
-      cursor = @conn.parse('SELECT lng from test_table order by id')
-      cursor.exec
-      assert_equal(test_data1, cursor.fetch[0])
-      assert_equal(test_data2, cursor.fetch[0])
-      assert_equal(test_data3, cursor.fetch[0])
-      assert_equal(test_data4, cursor.fetch[0])
-      cursor.close
+  # Set `OCI8::BindType::Base.initial_chunk_size = 5` to
+  # use the following test data.
+  LONG_TEST_DATA = [
+    # initial chunk size: 5 (total buffer size: 5)
+    'a' * 4, 'b' * 5, 'c' * 6, 'd' * 5, 'e' * 4,
+    # second chunk size: 10 (total buffer size: 15)
+    'f' * 14, 'g' * 15, 'h' * 16, 'i' * 15, 'j' * 14,
+    # third chunk size: 20 (total buffer size: 35)
+    'k' * 34, 'l' * 35, 'm' * 36, 'n' * 35, 'o' * 34,
+    # use data around initial chunk size again
+    'p' * 4, 'q' * 5, 'r' * 6, 's' * 5, 't' * 4,
+    # special data
+    '', nil,
+  ]
+
+  def test_long_type
+    clob_bind_type = OCI8::BindType::Mapping[:clob]
+    blob_bind_type = OCI8::BindType::Mapping[:blob]
+    initial_cunk_size = OCI8::BindType::Base.initial_chunk_size
+    begin
+      OCI8::BindType::Base.initial_chunk_size = 5
+      @conn.prefetch_rows = LONG_TEST_DATA.size / 3
+      drop_table('test_table')
+      ascii_enc = Encoding.find('US-ASCII')
+      0.upto(1) do |i|
+        if i == 0
+          @conn.exec("CREATE TABLE test_table (id number(38), long_column long, clob_column clob)")
+          cursor = @conn.parse('insert into test_table values (:1, :2, :3)')
+          cursor.bind_param(1, nil, Integer)
+          cursor.bind_param(2, nil, :long)
+          cursor.bind_param(3, nil, :clob)
+          lob = OCI8::CLOB.new(@conn, '')
+          enc = Encoding.default_internal || OCI8.encoding
+        else
+          @conn.exec("CREATE TABLE test_table (id number(38), long_raw_column long raw, blob_column blob)")
+          cursor = @conn.parse('insert into test_table values (:1, :2, :3)')
+          cursor.bind_param(1, nil, Integer)
+          cursor.bind_param(2, nil, :long_raw)
+          cursor.bind_param(3, nil, :blob)
+          lob = OCI8::BLOB.new(@conn, '')
+          enc = Encoding.find('ASCII-8BIT')
+        end
+
+        LONG_TEST_DATA.each_with_index do |data, index|
+          cursor[1] = index
+          cursor[2] = data
+          if data.nil?
+            cursor[3] = nil
+          else
+            lob.rewind
+            lob.write(data)
+            lob.size = data.size
+            cursor[3] = lob
+          end
+          cursor.exec
+        end
+        cursor.close
+
+        cursor = @conn.parse('SELECT * from test_table order by id')
+        cursor.exec
+        LONG_TEST_DATA.each_with_index do |data, index|
+          row = cursor.fetch
+          assert_equal(index, row[0])
+          if data.nil?
+            assert_nil(row[1])
+            assert_nil(row[2])
+          elsif data.empty?
+            # '' is inserted to the long or long raw column as null.
+            assert_nil(row[1])
+            # '' is inserted to the clob or blob column as an empty clob.
+            # It is fetched as '' when the data is read using a LOB locator.
+            assert_equal(data, clob_data = row[2].read)
+            assert_equal(ascii_enc, clob_data.encoding)
+          else
+            assert_equal(data, row[1])
+            assert_equal(data, clob_data = row[2].read)
+            assert_equal(enc, row[1].encoding)
+            assert_equal(enc, clob_data.encoding)
+          end
+        end
+        assert_nil(cursor.fetch)
+        cursor.close
+
+        begin
+          OCI8::BindType::Mapping[:clob] = OCI8::BindType::Long
+          OCI8::BindType::Mapping[:blob] = OCI8::BindType::LongRaw
+          cursor = @conn.parse('SELECT * from test_table order by id')
+          cursor.exec
+          LONG_TEST_DATA.each_with_index do |data, index|
+            row = cursor.fetch
+            assert_equal(index, row[0])
+            if data.nil?
+              assert_nil(row[1])
+              assert_nil(row[2])
+            elsif data.empty?
+              # '' is inserted to the long or long raw column as null.
+              assert_nil(row[1])
+              # '' is inserted to the clob or blob column as an empty clob.
+              # However it is fetched as nil.
+              assert_nil(row[2])
+            else
+              assert_equal(data, row[1])
+              assert_equal(data, row[2])
+              assert_equal(enc, row[1].encoding)
+              assert_equal(enc, row[2].encoding)
+            end
+          end
+          assert_nil(cursor.fetch)
+          cursor.close
+        ensure
+          OCI8::BindType::Mapping[:clob] = clob_bind_type
+          OCI8::BindType::Mapping[:blob] = blob_bind_type
+        end
+        drop_table('test_table')
+      end
+    ensure
+      OCI8::BindType::Base.initial_chunk_size = initial_cunk_size
     end
     drop_table('test_table')
   end
 
-  def test_long_type
-    @conn.long_read_len = 80000
-    drop_table('test_table')
-    @conn.exec('CREATE TABLE test_table (id number(38), lng long)')
-    test_data1 = 'a' * 70000
-    test_data2 = 'b' * 3000
-    test_data4 = 'c' * 70000
-    @conn.exec('insert into test_table values (:1, :2)', 1, test_data1)
-    @conn.exec('insert into test_table values (:1, :2)', 2, [test_data2, :long])
-    @conn.exec('insert into test_table values (:1, :2)', 3, [nil, :long])
-    @conn.exec('insert into test_table values (:1, :2)', 4, [test_data4, :long])
-
-    cursor = @conn.parse('SELECT lng from test_table order by id')
-    cursor.exec
-    assert_equal(test_data1, cursor.fetch[0])
-    assert_equal(test_data2, cursor.fetch[0])
-    assert_nil(cursor.fetch[0])
-    assert_equal(test_data4, cursor.fetch[0])
-    cursor.close
-    drop_table('test_table')
+  def test_bind_long_data
+    initial_cunk_size = OCI8::BindType::Base.initial_chunk_size
+    begin
+      OCI8::BindType::Base.initial_chunk_size = 5
+      cursor = @conn.parse("begin :1 := '<' || :2 || '>'; end;")
+      cursor.bind_param(1, nil, :long)
+      cursor.bind_param(2, nil, :long)
+      (LONG_TEST_DATA + ['z' * 4000]).each do |data|
+        cursor[2] = data
+        cursor.exec
+        assert_equal("<#{data}>", cursor[1])
+      end
+    ensure
+      OCI8::BindType::Base.initial_chunk_size = initial_cunk_size
+    end
   end
 
   def test_select
@@ -450,6 +539,7 @@ EOS
     assert_nil(@conn.last_error)
     @conn.last_error = 'dummy'
     cursor = @conn.parse('select col1, max(col2) from (select 1 as col1, null as col2 from dual) group by col1')
+    cursor.prefetch_rows = 1
     assert_nil(@conn.last_error)
 
     # When an OCI function returns OCI_SUCCESS_WITH_INFO, OCI8#last_error is set.
@@ -491,9 +581,44 @@ EOS
                        else
                          raise "Unknown column size #{column_size}"
                        end
-      driver_name = cursor.fetch[0]
+      driver_name = cursor.fetch[0].strip
       cursor.close
       assert_equal(expected_value, driver_name)
     end
   end
+
+  def test_server_version
+    cursor = @conn.exec("select * from product_component_version where product like 'Oracle Database %'")
+    row = cursor.fetch_hash
+    cursor.close
+    ver = if OCI8::oracle_client_version >= OCI8::ORAVER_18
+            row['VERSION_FULL'] || row['VERSION']
+          else
+            # OCI8#oracle_server_version could not get infomation corresponding
+            # to VERSION_FULL when the Oracle client version is below 18.1.
+            row['VERSION']
+          end
+    assert_equal(ver, @conn.oracle_server_version.to_s)
+  end
+
+  def test_array_fetch
+    drop_table('test_table')
+    @conn.exec("CREATE TABLE test_table (id number, val clob)")
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:1, :2)")
+    1.upto(10) do |i|
+      cursor.exec(i, ('a'.ord + i).chr * i)
+    end
+    cursor.close
+    cursor = @conn.parse("select * from test_table where id <= :1 order by id")
+    cursor.prefetch_rows = 4
+    [1, 6, 2, 7, 3, 8, 4, 9, 5, 10].each do |i|
+      cursor.exec(i)
+      1.upto(i) do |j|
+        row = cursor.fetch
+        assert_equal(j, row[0])
+        assert_equal(('a'.ord + j).chr * j, row[1].read)
+      end
+      assert_nil(cursor.fetch)
+    end
+  end
 end # TestOCI8