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

data/test/ConnectionTest.rb

@@ -1,111 +1,111 @@
-#!/usr/bin/env ruby
-
-require 'TestSetup'
-require 'test/unit'
-require 'rubygems'
-require 'fireruby'
-
-include FireRuby
-
-class ConnectionTest < Test::Unit::TestCase
-   CURDIR  = "#{Dir.getwd}"
-   DB_FILE = "#{CURDIR}#{File::SEPARATOR}con_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 = []
-   end
-   
-   def teardown
-      @connections.each {|connection| connection.close}
-      @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))
-      
-      assert(@connections[0].user == DB_USER_NAME)
-      assert(@connections[0].open?)
-      assert(@connections[0].closed? == false)
-      assert(@connections[0].database == @database)
-      assert(@connections[0].to_s == "#{DB_USER_NAME}@#{DB_FILE} (OPEN)")
-      
-      @connections[0].close
-      assert(@connections[0].user == DB_USER_NAME)
-      assert(@connections[0].open? == false)
-      assert(@connections[0].closed?)
-      assert(@connections[0].database == @database)
-      assert(@connections[0].to_s == "(CLOSED)")
-      
-      @connections[0] = @database.connect(DB_USER_NAME, DB_PASSWORD)
-      assert(@connections[0].open?)
-      @connections.push(Connection.new(@database, DB_USER_NAME, DB_PASSWORD))
-      assert(@connections[0].open?)
-      assert(@connections[1].open?)
-   end
-   
-   def test02
-      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
-      
-      tx = @connections[0].start_transaction
-      assert(tx != nil)
-      assert(tx.class == Transaction)
-      assert(tx.active?)
-      tx.rollback
-      
-      tx = nil
-      @connections[0].start_transaction do |transaction|
-         assert(transaction != nil)
-         assert(transaction.class == Transaction)
-         assert(transaction.active?)
-         tx = transaction
-      end
-      assert(tx != nil)
-      assert(tx.class == Transaction)
-      assert(tx.active? == false)
-   end
-   
-   def test03
-      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
-      tx    = @connections[0].start_transaction
-      total = 0
-      @connections[0].execute("SELECT RDB$FIELD_NAME FROM RDB$FIELDS", tx) do |row|
-         total = total + 1
-      end
-      assert(total == 88)
-      tx.commit
-
-      total = 0      
-      @connections[0].execute_immediate("SELECT RDB$FIELD_NAME FROM RDB$FIELDS") do |row|
-         total = total + 1
-      end
-      assert(total == 88)
-   end
-
-   def test04
-      connection = @database.connect(DB_USER_NAME, DB_PASSWORD)
-
-      tx1 = connection.start_transaction
-      tx2 = connection.start_transaction
-      tx3 = connection.start_transaction
-
-      tx2.rollback
-      assert(tx2.active? == false)
-
-      connection.close
-
-      assert(connection.closed?)
-      assert(tx1.active? == false)
-      assert(tx3.active? == false)
-   end
-end
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class ConnectionTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}con_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 = []
+   end
+   
+   def teardown
+      @connections.each {|connection| connection.close}
+      @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))
+      
+      assert(@connections[0].user == DB_USER_NAME)
+      assert(@connections[0].open?)
+      assert(@connections[0].closed? == false)
+      assert(@connections[0].database == @database)
+      assert(@connections[0].to_s == "#{DB_USER_NAME}@#{DB_FILE} (OPEN)")
+      
+      @connections[0].close
+      assert(@connections[0].user == DB_USER_NAME)
+      assert(@connections[0].open? == false)
+      assert(@connections[0].closed?)
+      assert(@connections[0].database == @database)
+      assert(@connections[0].to_s == "(CLOSED)")
+      
+      @connections[0] = @database.connect(DB_USER_NAME, DB_PASSWORD)
+      assert(@connections[0].open?)
+      @connections.push(Connection.new(@database, DB_USER_NAME, DB_PASSWORD))
+      assert(@connections[0].open?)
+      assert(@connections[1].open?)
+   end
+   
+   def test02
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      
+      tx = @connections[0].start_transaction
+      assert(tx != nil)
+      assert(tx.class == Transaction)
+      assert(tx.active?)
+      tx.rollback
+      
+      tx = nil
+      @connections[0].start_transaction do |transaction|
+         assert(transaction != nil)
+         assert(transaction.class == Transaction)
+         assert(transaction.active?)
+         tx = transaction
+      end
+      assert(tx != nil)
+      assert(tx.class == Transaction)
+      assert(tx.active? == false)
+   end
+   
+   def test03
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      tx    = @connections[0].start_transaction
+      total = 0
+      @connections[0].execute("SELECT RDB$FIELD_NAME FROM RDB$FIELDS", tx) do |row|
+         total = total + 1
+      end
+      assert(total == 88)
+      tx.commit
+
+      total = 0      
+      @connections[0].execute_immediate("SELECT RDB$FIELD_NAME FROM RDB$FIELDS") do |row|
+         total = total + 1
+      end
+      assert(total == 88)
+   end
+
+   def test04
+      connection = @database.connect(DB_USER_NAME, DB_PASSWORD)
+
+      tx1 = connection.start_transaction
+      tx2 = connection.start_transaction
+      tx3 = connection.start_transaction
+
+      tx2.rollback
+      assert(tx2.active? == false)
+
+      connection.close
+
+      assert(connection.closed?)
+      assert(tx1.active? == false)
+      assert(tx3.active? == false)
+   end
+end

data/test/DDLTest.rb

@@ -1,54 +1,54 @@
-#!/usr/bin/env ruby
-
-require 'TestSetup'
-require 'test/unit'
-require 'rubygems'
-require 'fireruby'
-
-include FireRuby
-
-class DDLTest < Test::Unit::TestCase
-   CURDIR  = "#{Dir.getwd}"
-   DB_FILE = "#{CURDIR}#{File::SEPARATOR}ddl_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)
-   end
-   
-   def teardown
-      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.execute_immediate('CREATE TABLE DDL_TABLE_01 (TABLEID '\
-                               'INTEGER NOT NULL, '\
-                               'FIELD01 FLOAT, FIELD02 CHAR(50), '\
-                               'FIELD03 BIGINT, FIELD04 TIMESTAMP '\
-                               'NOT NULL, FIELD05 VARCHAR(600))')
-
-         cxn.start_transaction do |tx|
-            r = tx.execute('SELECT COUNT(*) FROM DDL_TABLE_01')
-            assert(r.fetch[0] == 0)
-            r.close
-         end
-         
-         cxn.execute_immediate('ALTER TABLE DDL_TABLE_01 ADD PRIMARY KEY '\
-                               '(TABLEID)')
-                            
-         cxn.execute_immediate('CREATE UNIQUE INDEX DDL_TABLE_IDX ON '\
-                            'DDL_TABLE_01 (TABLEID)')
-                            
-         cxn.execute_immediate('DROP INDEX DDL_TABLE_IDX')
-      
-         cxn.execute_immediate('DROP TABLE DDL_TABLE_01')
-      end
-   end
-end
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class DDLTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}ddl_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)
+   end
+   
+   def teardown
+      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.execute_immediate('CREATE TABLE DDL_TABLE_01 (TABLEID '\
+                               'INTEGER NOT NULL, '\
+                               'FIELD01 FLOAT, FIELD02 CHAR(50), '\
+                               'FIELD03 BIGINT, FIELD04 TIMESTAMP '\
+                               'NOT NULL, FIELD05 VARCHAR(600))')
+
+         cxn.start_transaction do |tx|
+            r = tx.execute('SELECT COUNT(*) FROM DDL_TABLE_01')
+            assert(r.fetch[0] == 0)
+            r.close
+         end
+         
+         cxn.execute_immediate('ALTER TABLE DDL_TABLE_01 ADD PRIMARY KEY '\
+                               '(TABLEID)')
+                            
+         cxn.execute_immediate('CREATE UNIQUE INDEX DDL_TABLE_IDX ON '\
+                            'DDL_TABLE_01 (TABLEID)')
+                            
+         cxn.execute_immediate('DROP INDEX DDL_TABLE_IDX')
+      
+         cxn.execute_immediate('DROP TABLE DDL_TABLE_01')
+      end
+   end
+end

data/test/DatabaseTest.rb

@@ -1,83 +1,83 @@
-#!/usr/bin/env ruby
-
-require 'TestSetup'
-require 'test/unit'
-require 'rubygems'
-require 'fireruby'
-
-include FireRuby
-
-class DatabaseTest < Test::Unit::TestCase
-   CURDIR      = "#{Dir.getwd}"
-   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}db_unit_test.fdb"
-   CREATE_FILE = "#{CURDIR}#{File::SEPARATOR}db_create_test.fdb"
-   
-   def setup
-      puts "#{self.class.name} started." if TEST_LOGGING
-      if File.exist?(DB_FILE)
-         db = Database.new(DB_FILE)
-         db.drop
-      end
-      if File.exist?(CREATE_FILE)
-         db = Database.new(CREATE_FILE)
-         db.drop
-      end
-      
-      Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, 'ASCII')
-   end
-   
-   def teardown
-      if File::exist?(DB_FILE)
-         db = Database.new(DB_FILE)
-         db.drop(DB_USER_NAME, DB_PASSWORD)
-      end
-      if File::exist?(CREATE_FILE)
-         db = Database.new(CREATE_FILE)
-         db.drop(DB_USER_NAME, DB_PASSWORD)
-      end
-      puts "#{self.class.name} finished." if TEST_LOGGING
-   end
-   
-   
-   def test01
-      db = Database.create(CREATE_FILE, DB_USER_NAME, DB_PASSWORD, 2048, 'ASCII')
-      
-      assert(File.exist?(CREATE_FILE))
-      assert(db.file == CREATE_FILE)
-      
-      begin
-         Database.create(CREATE_FILE, DB_USER_NAME, DB_PASSWORD, 2048, 'ASCII')
-         assert(false,
-                "Successfully created a database file that already exists.")
-      rescue Exception
-      end
-      
-      db.drop(DB_USER_NAME, DB_PASSWORD)
-      assert(File.exist?(CREATE_FILE) == false)
-   end
-   
-   def test02
-      db = Database.new(DB_FILE);
-      
-      assert(db.file == DB_FILE)
-      
-      c = db.connect(DB_USER_NAME, DB_PASSWORD)
-      assert(c != nil)
-      c.close
-   end
-   
-   def test03
-      db = Database.new(DB_FILE);
-      c  = nil
-
-      db.connect(DB_USER_NAME, DB_PASSWORD) do |connection|
-         assert(connection != nil)
-         assert(connection.class == Connection)
-         assert(connection.open?)
-         c = connection
-      end
-      assert(c != nil)
-      assert(c.class == Connection)
-      assert(c.closed?)
-   end
-end
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class DatabaseTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}db_unit_test.fdb"
+   CREATE_FILE = "#{CURDIR}#{File::SEPARATOR}db_create_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
+      if File.exist?(CREATE_FILE)
+         db = Database.new(CREATE_FILE)
+         db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      
+      Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, 'ASCII')
+   end
+   
+   def teardown
+      if File::exist?(DB_FILE)
+         db = Database.new(DB_FILE)
+         db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      if File::exist?(CREATE_FILE)
+         db = Database.new(CREATE_FILE)
+         db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   
+   def test01
+      db = Database.create(CREATE_FILE, DB_USER_NAME, DB_PASSWORD, 2048, 'ASCII')
+      
+      assert(File.exist?(CREATE_FILE))
+      assert(db.file == CREATE_FILE)
+      
+      begin
+         Database.create(CREATE_FILE, DB_USER_NAME, DB_PASSWORD, 2048, 'ASCII')
+         assert(false,
+                "Successfully created a database file that already exists.")
+      rescue Exception
+      end
+      
+      db.drop(DB_USER_NAME, DB_PASSWORD)
+      assert(File.exist?(CREATE_FILE) == false)
+   end
+   
+   def test02
+      db = Database.new(DB_FILE);
+      
+      assert(db.file == DB_FILE)
+      
+      c = db.connect(DB_USER_NAME, DB_PASSWORD)
+      assert(c != nil)
+      c.close
+   end
+   
+   def test03
+      db = Database.new(DB_FILE);
+      c  = nil
+
+      db.connect(DB_USER_NAME, DB_PASSWORD) do |connection|
+         assert(connection != nil)
+         assert(connection.class == Connection)
+         assert(connection.open?)
+         c = connection
+      end
+      assert(c != nil)
+      assert(c.class == Connection)
+      assert(c.closed?)
+   end
+end