ruby-oci8 2.2.10-x64-mingw-ucrt

data/test/test_array_dml.rb

@@ -0,0 +1,332 @@
+require 'oci8'
+require File.dirname(__FILE__) + '/config'
+
+class TestArrayDML < Minitest::Test
+  def setup
+    @conn = get_oci8_connection
+  end
+
+  def teardown
+    @conn.logoff
+  end
+
+  # test inserting arrays with different data types
+  #   including char, varchar2, number, date and so on
+  def test_array_insert1
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (C CHAR(10) NOT NULL,
+   V VARCHAR2(20),
+   N NUMBER(10, 2),
+   D DATE,
+   INT NUMBER(30), 
+   BIGNUM NUMBER(30),
+   T TIMESTAMP)
+STORAGE (
+   INITIAL 4k
+   NEXT 4k
+   MINEXTENTS 1
+   MAXEXTENTS UNLIMITED
+   PCTINCREASE 0)
+EOS
+    @conn.exec(sql)
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:C, :V, :N, :D, :INT, :BIGNUM, :T)")
+    max_array_size = 3
+    cursor.max_array_size= max_array_size
+    
+    cursor.bind_param_array(1, nil, String)
+    cursor.bind_param_array(2, nil ,String)
+    cursor.bind_param_array(3, nil, Fixnum)
+    cursor.bind_param_array(4, nil, OraDate)
+    cursor.bind_param_array(5, nil, Integer)
+    cursor.bind_param_array(6, nil, Bignum)
+    cursor.bind_param_array(7, nil, DateTime)
+
+    c_arr = Array.new
+    v_arr = Array.new
+    n_arr = Array.new
+    d_arr = Array.new
+    int_arr = Array.new
+    bignum_arr = Array.new
+    t_arr = Array.new
+    
+    1.upto(30) do |i|
+      c_arr << format("%10d", i * 10)
+      v_arr << i.to_s
+      n_arr << i
+      d_arr <<  OraDate.new(2000 + i, 12, 24, 23, 59, 59)
+      int_arr << i * 11111111111
+      bignum_arr << i * 10000000000
+      t_arr <<  DateTime.new(2000 + i, 12, 24, 23, 59, 59)
+      
+      if i%max_array_size == 0
+        cursor[1] = c_arr
+        cursor[2] = v_arr
+        cursor[3] = n_arr
+        cursor[4] = d_arr
+        cursor[5] = int_arr
+        cursor[6] = bignum_arr
+        cursor[7] = t_arr
+        
+        r = cursor.exec_array
+        assert_equal(max_array_size, r)
+        assert_equal(c_arr, cursor[1])
+        assert_equal(v_arr, cursor[2])
+        assert_equal(n_arr, cursor[3])
+        assert_equal(d_arr, cursor[4])
+        assert_equal(int_arr, cursor[5])
+        assert_equal(bignum_arr, cursor[6])
+        assert_equal(t_arr, cursor[7])
+        c_arr.clear
+        v_arr.clear
+        n_arr.clear
+        d_arr.clear
+        int_arr.clear
+        bignum_arr.clear
+        t_arr.clear
+      end
+    end
+    cursor.close
+    
+    cursor = @conn.parse("SELECT * FROM test_table ORDER BY c")
+    cursor.define(5, Integer)
+    cursor.define(6, Bignum)
+    cursor.exec
+    assert_equal(["C","V","N","D","INT","BIGNUM","T"], cursor.get_col_names)
+    1.upto(30) do |i|
+      rv = cursor.fetch
+      assert_equal(format("%10d", i * 10), rv[0])
+      assert_equal(i.to_s, rv[1])
+      assert_equal(i, rv[2])
+      tm = Time.local(2000 + i, 12, 24, 23, 59, 59)
+      assert_equal(tm, rv[3])
+      assert_equal(i * 11111111111, rv[4])
+      assert_equal(i * 10000000000, rv[5])
+      assert_equal(tm, rv[6])
+    end
+    assert_nil(cursor.fetch)
+    drop_table('test_table')
+  end
+
+  # Raise error when binding arrays are not the same size
+  def test_array_insert2
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (N NUMBER(10, 2) NOT NULL,
+   V VARCHAR(20))
+EOS
+    @conn.exec(sql)
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:N, :V)")
+    max_array_size = 10
+    cursor.max_array_size = max_array_size
+    cursor.bind_param_array(1, nil, Fixnum)
+    cursor.bind_param_array(2, nil, String)
+    n_arr = Array.new
+    v_arr = Array.new
+    1.upto(max_array_size) do |i|
+      n_arr << i
+      v_arr << i.to_s if i != max_array_size
+    end
+    cursor[1] = n_arr
+    assert_raises(RuntimeError) { cursor[2] = v_arr }
+    cursor.close
+    
+    drop_table('test_table')
+  end  
+
+  # All binds are clear from cursor after calling "max_array_size=", 
+  #  in that case, you have to re-bind the array parameters 
+  #  otherwise, an error will be raised.
+  def test_array_insert3
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (N NUMBER(10, 2) NOT NULL,
+   V VARCHAR(20),
+   T TIMESTAMP)
+EOS
+    @conn.exec(sql)
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:N, :V, :T)")
+    cursor.max_array_size = 3
+    cursor.bind_param_array(1, [1, 2, 3])
+    cursor.bind_param_array(2, ['happy', 'new', 'year'])
+    cursor.bind_param_array(3, [Time.gm(1990,1,1), Time.gm(2000,1,1), Time.gm(2010,1,1)])
+    cursor.exec_array
+    cursor.max_array_size = 2
+    assert_raises(RuntimeError) { cursor.exec_array }
+    drop_table('test_table')
+  end
+
+  # The size of binding arrays are not required to be same as max_array_size. The 
+  #   only requirement is that they should be the same size, and the size will be 
+  #   used as execution count for OCIStmtExecute.
+  def test_array_insert4
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (N NUMBER(10, 2) NOT NULL,
+   V VARCHAR(20))
+EOS
+    @conn.exec(sql)
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:N, :V)")
+    max_array_size = 4
+    cursor.max_array_size = max_array_size
+    cursor.bind_param_array(1, nil, Fixnum)
+    cursor.bind_param_array(2, nil, String)
+    n_arr = Array.new
+    v_arr = Array.new
+    1.upto( max_array_size - 1 ) do |i|
+      n_arr << i
+      v_arr << i.to_s
+    end
+    cursor[1] = n_arr
+    cursor[2] = v_arr
+    cursor.exec_array
+    cursor.close
+
+    cursor = @conn.parse("SELECT * FROM test_table ORDER BY N")
+    cursor.exec
+    1.upto( max_array_size - 1 ) do |i|
+      rv = cursor.fetch
+      assert_equal(i, rv[0])
+      assert_equal(i.to_s, rv[1])
+    end  
+    assert_nil(cursor.fetch)
+    cursor.close
+    drop_table('test_table')    
+  end
+
+  # Inserting "nil" elements with array dml raises an error
+  def test_array_insert5
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (N NUMBER(10, 2),
+   V VARCHAR(20))
+EOS
+    @conn.exec(sql)
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:N, :V)")
+    max_array_size = 3
+    cursor.max_array_size = max_array_size
+    cursor.bind_param_array(1, nil, Fixnum)
+    cursor.bind_param_array(2, nil, String)
+    assert_raises(RuntimeError) { cursor.exec_array }
+    cursor.close
+    drop_table('test_table')
+  end
+
+  # delete with array bindings
+  def test_array_delete
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (N NUMBER(10, 2),
+   V VARCHAR(20))
+EOS
+    @conn.exec(sql)    
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:N, :V)")
+    max_array_size = 10
+    cursor.max_array_size = max_array_size
+    n_arr = Array.new
+    v_arr = Array.new
+    1.upto( max_array_size) do |i|
+      n_arr << i
+      v_arr << i.to_s
+    end    
+    cursor.bind_param_array(1, nil, Fixnum)
+    cursor.bind_param_array(2, nil, String)
+    cursor[1] = n_arr
+    cursor[2] = v_arr
+    cursor.exec_array
+    cursor.close
+
+    cursor = @conn.parse("DELETE FROM test_table WHERE N=:1")
+    cursor.max_array_size = max_array_size
+    delete_arr = Array.new
+    1.upto(max_array_size) do |i|
+      if i%2 == 0
+        delete_arr << i
+      end  
+    end
+    cursor.bind_param_array(1, nil, Fixnum)
+    cursor[1] = delete_arr
+    cursor.exec_array
+    cursor.close
+    
+    cursor = @conn.parse("SELECT * FROM test_table ORDER BY N")
+    cursor.exec
+    1.upto( max_array_size ) do |i|
+      if i%2 != 0
+        rv = cursor.fetch
+        assert_equal(rv[0], i)
+        assert_equal(rv[1], i.to_s)
+      end
+    end  
+    assert_nil(cursor.fetch)    
+    cursor.close
+    
+    drop_table('test_table')
+  end
+
+  # update with array bindings
+  def test_array_update
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (N NUMBER(10, 2),
+   V VARCHAR(20))
+EOS
+    @conn.exec(sql)    
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:N, :V)")
+    max_array_size = 10
+    cursor.max_array_size = max_array_size
+    n_arr = Array.new
+    v_arr = Array.new
+    1.upto( max_array_size) do |i|
+      n_arr << i
+      v_arr << i.to_s
+    end    
+    cursor.bind_param_array(1, nil, Fixnum)
+    cursor.bind_param_array(2, nil, String)
+    cursor[1] = n_arr
+    cursor[2] = v_arr
+    cursor.exec_array
+    cursor.close
+
+    cursor = @conn.parse("UPDATE test_table SET V=:1 WHERE N=:2")
+    cursor.max_array_size = max_array_size
+    update_arr = Array.new
+    update_v_arr = Array.new
+    1.upto(max_array_size) do |i|
+      if i%2 == 0
+        update_arr << i
+        update_v_arr << (i * 10).to_s
+      end  
+    end
+    cursor.bind_param_array(1, nil, String)
+    cursor.bind_param_array(2, nil, Fixnum)
+    cursor[1] = update_v_arr
+    cursor[2] = update_arr
+    cursor.exec_array
+    cursor.close
+    
+    cursor = @conn.parse("SELECT * FROM test_table ORDER BY N")
+    cursor.exec
+    1.upto( max_array_size ) do |i|
+      rv = cursor.fetch      
+      if i%2 != 0
+        assert_equal(rv[0], i)
+        assert_equal(rv[1], i.to_s)
+      else
+        assert_equal(rv[0], i)
+        assert_equal(rv[1], (i * 10).to_s)
+      end
+    end  
+    assert_nil(cursor.fetch)    
+
+    cursor.close
+    drop_table('test_table')
+  end
+end

data/test/test_bind_array.rb

@@ -0,0 +1,70 @@
+require 'oci8'
+require File.dirname(__FILE__) + '/config'
+
+class TestBindArray < Minitest::Test
+
+  def test_bind_array_names
+    assert_equal(":id_0", OCI8::in_cond(:id, []).names)
+    assert_equal(":id_0", OCI8::in_cond(:id, [1]).names)
+    assert_equal(":id_0, :id_1", OCI8::in_cond(:id, [1, 2]).names)
+    assert_equal(":id_0, :id_1, :id_2", OCI8::in_cond(:id, [1, 2, 3]).names)
+  end
+
+  def test_bind_array_values
+    assert_equal([[nil, String, nil]], OCI8::in_cond(:id, []).values)
+    assert_equal([[1, nil, nil]], OCI8::in_cond(:id, [1]).values)
+    assert_equal([[1, nil, nil], [2, nil, nil]], OCI8::in_cond(:id, [1, 2]).values)
+    assert_equal([[1, nil, nil], [2, nil, nil], [3, nil, nil]], OCI8::in_cond(:id, [1, 2, 3]).values)
+  end
+
+  def test_bind_array_values_containg_nil
+    assert_equal([[nil, String]], OCI8::in_cond(:id, [nil]).values)
+    assert_equal([[nil, Fixnum], [2, nil, nil], [3, nil, nil]], OCI8::in_cond(:id, [nil, 2, 3]).values)
+    assert_equal([[1, nil, nil], [nil, Fixnum], [3, nil, nil]], OCI8::in_cond(:id, [1, nil, 3]).values)
+  end
+
+  def test_bind_array_values_with_type
+    assert_equal([[nil, Integer, nil]], OCI8::in_cond(:id, [], Integer).values)
+    assert_equal([[1, Integer, nil]], OCI8::in_cond(:id, [1], Integer).values)
+    assert_equal([[1, Integer, nil], [2, Integer, nil]], OCI8::in_cond(:id, [1, 2], Integer).values)
+    assert_equal([[1, Integer, nil], [2, Integer, nil], [3, Integer, nil]], OCI8::in_cond(:id, [1, 2, 3], Integer).values)
+    assert_equal([[nil, Integer, nil], [2, Integer, nil], [3, Integer, nil]], OCI8::in_cond(:id, [nil, 2, 3], Integer).values)
+    assert_equal([[1, Integer, nil], [nil, Integer, nil], [3, Integer, nil]], OCI8::in_cond(:id, [1, nil, 3], Integer).values)
+  end
+
+  def test_select
+    @conn = get_oci8_connection
+    begin
+      drop_table('test_table')
+      @conn.exec(<<EOS)
+CREATE TABLE test_table (ID NUMBER(38))
+EOS
+      cursor = @conn.parse('insert into test_table values(:1)')
+      cursor.bind_param(1, nil, Integer)
+      [1, 3, 5].each do |id|
+        cursor.exec(id)
+      end
+      cursor.close
+
+      [
+       [],
+       [1],
+       [1, 2],
+       [1, 2, 3],
+       [nil],
+       [nil, 2, 3],
+       [1, nil, 3],
+      ].each do |ids|
+        in_cond = OCI8::in_cond(:id, ids)
+        cursor = @conn.exec("select * from test_table where id in (#{in_cond.names}) order by id", *in_cond.values)
+        ([1, 3, 5] & ids).each do |id|
+          assert_equal(id, cursor.fetch[0])
+        end
+      end
+
+      drop_table('test_table')
+    ensure
+      @conn.logoff
+    end
+  end
+end

data/test/test_bind_boolean.rb

@@ -0,0 +1,99 @@
+# Low-level API
+require 'oci8'
+require File.dirname(__FILE__) + '/config'
+
+class TestBindBoolean < Minitest::Test
+  def setup
+    @conn = get_oci8_connection()
+  end
+
+  def test_set_raw
+    stmt = <<EOS
+DECLARE
+  bool_val boolean;
+  int_val pls_integer;
+BEGIN
+  bool_val := :in;
+  IF bool_val THEN
+    int_val := 1;
+  ELSE
+    int_val := 0;
+  END IF;
+  :out := int_val;
+END;
+EOS
+    # explicit bind
+    cursor = @conn.parse(stmt)
+    cursor.bind_param(:in, nil, TrueClass)
+    cursor.bind_param(:out, nil, Integer)
+
+    cursor[:in] = true
+    cursor.exec
+    assert_equal(1, cursor[:out])
+
+    cursor[:in] = false
+    cursor.exec
+    assert_equal(0, cursor[:out])
+
+    # implicit bind
+    do_block_cnt = 0
+    @conn.exec(stmt, true, 0) do |in_val, out_val|
+      assert_equal(true, in_val)
+      assert_equal(1, out_val)
+      do_block_cnt += 1
+    end
+
+    @conn.exec(stmt, false, 0) do |in_val, out_val|
+      assert_equal(false, in_val)
+      assert_equal(0, out_val)
+      do_block_cnt += 1
+    end
+    assert_equal(2, do_block_cnt)
+  end
+
+  def test_get_raw
+    stmt = <<EOS
+DECLARE
+  int_val pls_integer;
+  bool_val boolean;
+BEGIN
+  int_val := :in;
+  IF int_val <> 0 THEN
+    bool_val := TRUE;
+  ELSE
+    bool_val := FALSE;
+  END IF;
+  :out := bool_val;
+END;
+EOS
+    cursor = @conn.parse(stmt)
+    cursor.bind_param(:in, nil, Integer)
+    cursor.bind_param(:out, nil, TrueClass)
+
+    cursor[:in] = 1
+    cursor.exec
+    assert_equal(true, cursor[:out])
+
+    cursor[:in] = 0
+    cursor.exec
+    assert_equal(false, cursor[:out])
+
+    do_block_cnt = 0
+    @conn.exec(stmt, 1, true) do |in_val, out_val|
+      assert_equal(1, in_val)
+      assert_equal(true, out_val)
+      do_block_cnt += 1
+    end
+
+    @conn.exec(stmt, 0, true) do |in_val, out_val|
+      assert_equal(0, in_val)
+      assert_equal(false, out_val)
+      do_block_cnt += 1
+    end
+    assert_equal(2, do_block_cnt)
+  end
+
+  def teardown
+    @conn.logoff
+  end
+end

data/test/test_bind_integer.rb

@@ -0,0 +1,47 @@
+require 'oci8'
+require File.dirname(__FILE__) + '/config'
+
+class TestBindInteger < Minitest::Test
+
+  def setup
+    @conn = get_oci8_connection
+  end
+
+  POSITIVE_INTS = [
+    100,
+    2**30,
+    2**31,
+    2**32,
+    2**33,
+    2**62,
+    2**63,
+    2**64,
+    ('9' * 38).to_i
+  ]
+
+  def bind_and_get(input_value, output_type)
+    cursor = @conn.parse("BEGIN :out := :in; END;")
+    cursor.bind_param(:out, output_type)
+    cursor.bind_param(:in, input_value)
+    cursor.exec
+    result = cursor[:out]
+    cursor.close
+    result
+  end
+
+  (POSITIVE_INTS + [0] + POSITIVE_INTS.map(&:-@)).each do |num|
+    define_method("test_bind_param_with_input_of '#{num}'") do
+      assert_equal(OraNumber.new(num.to_s), bind_and_get(num, OraNumber))
+    end
+
+    define_method("test_bind_param_with_output_of '#{num}'") do
+      result = bind_and_get(OraNumber.new(num.to_s), Integer)
+      assert_equal(num, result)
+      assert_kind_of(Integer, result)
+    end
+  end
+
+  def teardown
+    @conn.logoff
+  end
+end

data/test/test_bind_raw.rb

@@ -0,0 +1,45 @@
+# Low-level API
+require 'oci8'
+require File.dirname(__FILE__) + '/config'
+
+class TestBindRaw < Minitest::Test
+  CHECK_TARGET = [
+    ["0123456789:;<=>?", "303132333435363738393A3B3C3D3E3F"],
+    ["@ABCDEFGHIJKLMNO", "404142434445464748494A4B4C4D4E4F"],
+    ["PQRSTUVWXYZ[\\]^_", "505152535455565758595A5B5C5D5E5F"],
+    ["`abcdefghijklmno", "606162636465666768696A6B6C6D6E6F"],
+    ["pqrstuvwxyz{|}~", "707172737475767778797A7B7C7D7E"],
+  ]
+
+  def setup
+    @conn = get_oci8_connection()
+  end
+
+  def test_set_raw
+    cursor = @conn.parse("BEGIN :hex := RAWTOHEX(:raw); END;")
+    cursor.bind_param(:raw, nil, OCI8::RAW, 16)
+    cursor.bind_param(:hex, nil, String, 32)
+
+    CHECK_TARGET.each do |raw, hex|
+      cursor[:raw] = raw
+      cursor.exec
+      assert_equal(hex, cursor[:hex])
+    end
+  end
+
+  def test_get_raw
+    cursor = @conn.parse("BEGIN :raw := HEXTORAW(:hex); END;")
+    cursor.bind_param(:hex, nil, String, 32)
+    cursor.bind_param(:raw, nil, OCI8::RAW, 16)
+
+    CHECK_TARGET.each do |raw, hex|
+      cursor[:hex] = hex
+      cursor.exec
+      assert_equal(raw, cursor[:raw])
+    end
+  end
+
+  def teardown
+    @conn.logoff
+  end
+end

data/test/test_bind_string.rb

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+require 'oci8'
+require File.dirname(__FILE__) + '/config'
+
+class TestBindString < Minitest::Test
+  def setup
+    @conn = get_oci8_connection
+  end
+
+  def teardown
+    @conn.logoff
+  end
+
+  if OCI8.client_charset_name.include? 'UTF8'
+
+    def test_bind_string_as_nchar
+      if ['AL32UTF8', 'UTF8', 'ZHS32GB18030'].include? @conn.database_charset_name
+        warn "Skip test_bind_string_as_nchar. It needs Oracle server whose database chracter set is incompatible with unicode."
+      else
+        drop_table('test_table')
+        @conn.exec("CREATE TABLE test_table (ID NUMBER(5), V VARCHAR2(10), NV1 NVARCHAR2(10), NV2 NVARCHAR2(10))")
+
+        orig_prop = OCI8.properties[:bind_string_as_nchar]
+        begin
+          utf8_string = "a¡あ"
+
+          OCI8.properties[:bind_string_as_nchar] = false
+          @conn.exec("INSERT INTO test_table VALUES (1, N'#{utf8_string}', N'#{utf8_string}', :1)", utf8_string)
+          v, nv1, nv2 = @conn.select_one('select V, NV1, NV2 from test_table where ID = 1')
+          assert_not_equal(utf8_string, v) # Some UTF-8 chracters should be garbled.
+          assert_equal(utf8_string, nv1) # No garbled characters
+          assert_equal(v, nv2) # Garbled as VARCHAR2 column.
+
+          OCI8.properties[:bind_string_as_nchar] = true
+          @conn.exec("INSERT INTO test_table VALUES (2, N'#{utf8_string}', N'#{utf8_string}', :1)", utf8_string)
+          v, nv1, nv2 = @conn.select_one('select V, NV1, NV2 from test_table where ID = 2')
+          assert_not_equal(utf8_string, v) # Some UTF-8 chracters should be garbled.
+          assert_equal(utf8_string, nv1) # No garbled characters
+          assert_equal(nv1, nv2) # Same as NVARCHAR2.
+
+          @conn.commit
+        ensure
+          OCI8.properties[:bind_string_as_nchar] = orig_prop
+        end
+      end
+    end
+
+    def test_length_semantics # This test needs to be revised.
+      orig_prop = OCI8.properties[:length_semantics]
+      begin
+        utf8_string = "a¡あ"
+
+        OCI8.properties[:length_semantics] = :byte
+        assert_equal(:byte, OCI8.properties[:length_semantics])
+        cursor = @conn.parse <<EOS
+DECLARE
+  TMP VARCHAR2(6);
+BEGIN
+  TMP := :in;
+  :out := TMP;
+END;
+EOS
+        cursor.bind_param(:in, utf8_string)
+        cursor.bind_param(:out, nil, String, 5)
+        begin
+          cursor.exec
+        rescue OCIError
+          assert_equal(6502, $!.code)
+        end
+        cursor.bind_param(:out, nil, String, 6)
+        cursor.exec
+        assert_equal(utf8_string, cursor[:out])
+
+        OCI8.properties[:length_semantics] = :char
+        assert_equal(:char, OCI8.properties[:length_semantics])
+        cursor = @conn.parse <<EOS
+DECLARE
+  TMP VARCHAR2(6);
+BEGIN
+  TMP := :in;
+  :out := TMP;
+END;
+EOS
+        cursor.bind_param(:in, utf8_string, String, 3)
+        cursor.bind_param(:out, nil, String, 2)
+        begin
+          cursor.exec
+        rescue OCIError
+          assert_equal(6502, $!.code)
+        end
+        cursor.bind_param(:out, nil, String, 3)
+        cursor.exec
+        assert_equal(utf8_string, cursor[:out])
+      ensure
+        OCI8.properties[:length_semantics] = orig_prop
+      end
+    end
+
+  else
+
+    def test_dummy
+      # to suppress "No tests were specified."
+    end
+  end
+end