sqlpostgres 1.2.4

data/test/PgPoint.test.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+require 'RandomThings'
+
+class PgPointTest < Test
+
+  include SqlPostgres
+  include RandomThings
+
+  def test_ctor_defaults
+    assertEquals(PgPoint.new, PgPoint.new(0, 0))
+  end
+
+  def test_ctor_and_accessors
+    x = randomFloat
+    y = randomFloat
+    point = PgPoint.new(x, y)
+    assertEquals(point.x, x)
+    assertEquals(point.y, y)
+  end
+
+  def test_from_sql
+    testCases = [
+      ["(0,0)", [0, 0]],
+      ["(1.2,-3)", [1.2, -3]],
+      ["(1e+20,-1e+20)", [1e20, -1e20]],
+    ]
+    for testCase in testCases
+      sql, args = *testCase
+      assertInfo("For sql #{sql.inspect}") do
+        assertEquals(PgPoint.from_sql(sql), PgPoint.new(*args))
+      end
+    end
+    assertException(ArgumentError, 'Invalid point: "foo"') do
+      PgPoint.from_sql("foo")
+    end
+  end
+
+  def test_equality
+    fields = ["x", "y"]
+    for field in fields
+      assertInfo("For field #{field}") do
+        point1 = PgPoint.new
+        point2 = PgPoint.new
+        assertEquals(point1.eql?(point2), true)
+        assertEquals(point1 == point2, true)
+        assertEquals(point1 != point2, false)
+        args = fields.collect do |f|
+          if f == field then 1 else 0 end
+        end
+        point2 = PgPoint.new(*args)
+        assertEquals(point1 == point2, false)
+        assertEquals(point1 != point2, true)
+        assertEquals(point1.eql?(Object.new), false)
+        assertEquals(point1 == Object.new, false)
+      end
+    end
+  end
+
+  def test_hash
+    count = 0
+    hashes = Hash.new(0)
+    testHash = proc { |*args|
+      assertEquals(PgPoint.new(*args).hash, PgPoint.new(*args).hash)
+      hashes[PgPoint.new(*args).hash] += 1
+      count += 1
+    }
+    for i in (0...10)
+      testHash.call(i, 0)
+      testHash.call(0, i)
+    end
+    assertGreaterOrEqual(hashes.size.to_f / count, 0.5)
+  end
+
+  def test_to_s
+    testCases = [
+      [[0, 0], "(0, 0)"],
+      [[1.2, -2], "(1.2, -2)"],
+      [[1e10, -1e10], "(1e+10, -1e+10)"],
+    ]
+    for testCase in testCases
+      args, expected = *testCase
+      assertEquals(PgPoint.new(*args).to_s, expected)
+      assertEquals(PgPoint.new(*args).to_sql, "point '#{expected}'")
+    end
+  end
+
+end
+
+PgPointTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/PgPolygon.test.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+require 'RandomThings'
+
+class PgPolygonTest < Test
+
+  include SqlPostgres
+  include RandomThings
+
+  def test_ctor_defaults
+    assertEquals(PgPolygon.new.points, [])
+  end
+
+  def test_ctor
+    testCases = [
+      [],
+      [PgPoint.new(1, 1)],
+      [PgPoint.new(1, 1), PgPoint.new(2, 2)],
+    ]
+    for points in testCases
+      assertEquals(PgPolygon.new(*points).points, points)
+    end
+  end
+
+  def test_from_sql
+    testCases = [
+      ["((0,0))", [PgPoint.new(0, 0)]],
+      ["((1,2),(3,4))", [PgPoint.new(1, 2), PgPoint.new(3, 4)]],
+    ]
+    for sql, args in testCases
+      assertInfo("For sql #{sql.inspect}") do
+        assertEquals(PgPolygon.from_sql(sql), PgPolygon.new(*args))
+      end
+    end
+    assertException(ArgumentError, 'Invalid polygon: "foo"') do
+      PgPolygon.from_sql("foo")
+    end
+  end
+
+  def test_to_s
+    testCases = [
+      [[PgPoint.new(1, 1)], "((1, 1))"],
+      [[PgPoint.new(1, 1), PgPoint.new(2, 2)], "((1, 1), (2, 2))"],
+    ]
+    for args, expected in testCases
+      assertInfo("For args #{args.inspect}") do
+        assertEquals(PgPolygon.new(*args).to_s, expected)
+        assertEquals(PgPolygon.new(*args).to_sql, "polygon '#{expected}'")
+      end
+    end
+  end
+
+  def test_equality
+    polygon1 = PgPolygon.new(false)
+    polygon2 = PgPolygon.new(false)
+    assertEquals(polygon1.eql?(polygon2), true)
+    assertEquals(polygon1 == polygon2, true)
+    assertEquals(polygon1 != polygon2, false)
+    polygon2 = PgPolygon.new(PgPoint.new(1, 2))
+    assertEquals(polygon1 == polygon2, false)
+    assertEquals(polygon1 != polygon2, true)
+    assertEquals(polygon1.eql?(Object.new), false)
+    assertEquals(polygon1 == Object.new, false)
+  end
+
+  def test_hash
+    count = 0
+    hashes = Hash.new(0)
+    testHash = proc { |*args|
+      assertEquals(PgPolygon.new(*args).hash, PgPolygon.new(*args).hash)
+      hashes[PgPolygon.new(*args).hash] += 1
+      count += 1
+    }
+    for i in (0...10)
+      testHash.call(PgPoint.new(i, 0), PgPoint.new(0, 0))
+      testHash.call(PgPoint.new(0, i), PgPoint.new(0, 0))
+      testHash.call(PgPoint.new(0, 0), PgPoint.new(i, 0))
+      testHash.call(PgPoint.new(0, 0), PgPoint.new(0, i))
+    end
+    assertGreaterOrEqual(hashes.size.to_f / count, 0.5)
+  end
+
+end
+
+PgPolygonTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/PgTime.test.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+require 'RandomThings'
+
+class PgTimeTest < Test
+
+  include SqlPostgres
+  include RandomThings
+
+  def test_ctor_defaults
+    assertEquals(PgTime.new, PgTime.new(0, 0, 0))
+  end
+
+  def test_ctor_and_accessors
+    hour = randomInteger
+    minute = randomInteger
+    second = randomInteger
+    time = PgTime.new(hour, minute, second)
+    assertEquals(time.hour, hour)
+    assertEquals(time.minute, minute)
+    assertEquals(time.second, second)
+  end
+
+  def test_from_sql
+    testCases = [
+      [0, 0, 0],
+      [23, 59, 59],
+    ]
+    for testCase in testCases
+      sql = "%02d:%02d:%02d" % testCase
+    assertEquals(PgTime.from_sql(sql), PgTime.new(*testCase))
+    end
+  end
+
+  def test_equality
+    fields = ["hour", "minute", "second"]
+    for field in fields
+      assertInfo("For field #{field}") do
+        time1 = PgTime.new
+        time2 = PgTime.new
+        assertEquals(time1.eql?(time2), true)
+        assertEquals(time1 == time2, true)
+        assertEquals(time1 != time2, false)
+        args = fields.collect do |f|
+          if f == field then 1 else 0 end
+        end
+        time2 = PgTime.new(*args)
+        assertEquals(time1 == time2, false)
+        assertEquals(time1 != time2, true)
+        assertEquals(time1.eql?(Object.new), false)
+        assertEquals(time1 == Object.new, false)
+      end
+    end
+  end
+
+  def test_hash
+    count = 0
+    hashes = Hash.new(0)
+    testHash = proc { |*args|
+      assertEquals(PgTime.new(*args).hash, PgTime.new(*args).hash)
+      hashes[PgTime.new(*args).hash] += 1
+      count += 1
+    }
+    for i in (0...10)
+      testHash.call(i, 0, 0)
+      testHash.call(0, i, 0)
+      testHash.call(0, 0, i)
+    end
+    assertGreaterOrEqual(hashes.size.to_f / count, 0.5)
+  end
+
+  def test_to_s
+    testCases = [
+      [[0, 0, 0], "00:00:00"],
+      [[23, 59, 59], "23:59:59"],
+    ]
+    for testCase in testCases
+      args, expected = *testCase
+      assertEquals(PgTime.new(*args).to_s, expected)
+      assertEquals(PgTime.new(*args).to_sql, "time '#{expected}'")
+    end
+  end
+
+  def test_to_local_time
+    testCases = [
+      [0, 0, 0],
+      [12, 13, 14],
+      [23, 59, 59],
+    ]
+    for testCase in testCases
+      time = Time.local(1970, 1, 1, *testCase)
+      assertEquals(PgTime.new(*testCase).to_local_time, time)
+    end
+  end
+
+  def test_to_utc_time
+    testCases = [
+      [0, 0, 0],
+      [12, 13, 14],
+      [23, 59, 59],
+    ]
+    for testCase in testCases
+      time = Time.utc(1970, 1, 1, *testCase)
+      assertEquals(PgTime.new(*testCase).to_utc_time, time)
+    end
+  end
+
+end
+
+PgTimeTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/PgTimeWithTimeZone.test.rb

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+require 'RandomThings'
+
+class PgTimeWithTimeZoneTest < Test
+
+  include SqlPostgres
+  include RandomThings
+
+  def test_ctor_defaults
+    assertEquals(PgTimeWithTimeZone.new, 
+                 PgTimeWithTimeZone.new(0, 0, 0, 0, 0))
+  end
+
+  def test_ctor_and_accessors
+    hour = randomInteger
+    minute = randomInteger
+    second = randomInteger
+    zone_hours = randomInteger
+    zone_minutes = randomInteger
+    time = PgTimeWithTimeZone.new(hour, minute, second, 
+                                  zone_hours, zone_minutes)
+    assertEquals(time.hour, hour)
+    assertEquals(time.minute, minute)
+    assertEquals(time.second, second)
+    assertEquals(time.zone_hours, zone_hours)
+    assertEquals(time.zone_minutes, zone_minutes)
+  end
+
+  def test_from_sql
+    testCases = [
+      ["12:00:00+00:30", [12, 0, 0, 0, 30]],
+      ["00:00:00+08", [0, 0, 0, 8, 0]],
+      ["00:00:00+08:30", [0, 0, 0, 8, 30]],
+      ["23:59:59-08", [23, 59, 59, -8, 0]],
+    ]
+    for testCase in testCases
+      sql, args = *testCase
+      assertInfo("For sql #{sql.inspect}") do
+        assertEquals(PgTimeWithTimeZone.from_sql(sql), 
+                     PgTimeWithTimeZone.new(*args))
+      end
+    end
+    assertException(ArgumentError, 'Invalid time with time zone: "foo"') do
+      PgTimeWithTimeZone.from_sql("foo")
+    end
+  end
+
+  def test_equality
+    fields = ["hour", "minute", "second", "zone_hours", "zone_minutes"]
+    for field in fields
+      assertInfo("For field #{field}") do
+        time1 = PgTimeWithTimeZone.new
+        time2 = PgTimeWithTimeZone.new
+        assertEquals(time1.eql?(time2), true)
+        assertEquals(time1 == time2, true)
+        assertEquals(time1 != time2, false)
+        args = fields.collect do |f|
+          if f == field then 1 else 0 end
+        end
+        time2 = PgTimeWithTimeZone.new(*args)
+        assertEquals(time1 == time2, false)
+        assertEquals(time1 != time2, true)
+        assertEquals(time1.eql?(Object.new), false)
+        assertEquals(time1 == Object.new, false)
+      end
+    end
+  end
+
+  def test_hash
+    count = 0
+    hashes = Hash.new(0)
+    testHash = proc { |*args|
+      assertEquals(PgTimeWithTimeZone.new(*args).hash, 
+                   PgTimeWithTimeZone.new(*args).hash)
+      hashes[PgTimeWithTimeZone.new(*args).hash] += 1
+      count += 1
+    }
+    for i in (0...10)
+      testHash.call(i, 0, 0, 0, 0)
+      testHash.call(0, i, 0, 0, 0)
+      testHash.call(0, 0, i, 0, 0)
+      testHash.call(0, 0, 0, i, 0)
+      testHash.call(0, 0, 0, 0, i)
+    end
+    assertGreaterOrEqual(hashes.size.to_f / count, 0.5)
+  end
+
+  def test_to_s_and_to_sql
+    testCases = [
+      [[0, 0, 0, 0, 0], "00:00:00+00:00"],
+      [[12, 0, 0, -8, 0], "12:00:00-08:00"],
+      [[23, 59, 59, 23, 0], "23:59:59+23:00"],
+    ]
+    for testCase in testCases
+      assertInfo("for test case #{testCase.inspect}") do
+        args, expected = *testCase
+        t = PgTimeWithTimeZone.new(*args)
+        assertEquals(t.to_s, expected)
+        assertEquals(t.to_sql, "time with time zone '#{t}'")
+      end
+    end
+  end
+
+end
+
+PgTimeWithTimeZoneTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/PgTimestamp.test.rb

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+require 'RandomThings'
+
+class PgTimestampTest < Test
+
+  include SqlPostgres
+  include RandomThings
+
+  def test_ctor_and_accessors
+    fields = [:year, :month, :day, :hour, :minute, :second, :microseconds].collect do |field|
+      [field, randomInteger]
+    end
+    timestamp = PgTimestamp.new(*fields.collect do |field, value| value end)
+    for field, value in fields
+      assertInfo("For field #{field}") do
+        assertEquals(timestamp.send(field), value)
+      end
+    end
+  end
+
+  def test_ctor_defaults
+    for number_of_args in (0..7)
+      assertInfo("For number_of_args=#{number_of_args}") do
+        assertEquals(PgTimestamp.new,
+                     PgTimestamp.new(*([0] * number_of_args)))
+      end
+    end
+  end
+
+  def test_equality
+    fields = ["year", "month", "day", "hour", "minute", "second", "microseconds"]
+    for field in fields
+      assertInfo("For field #{field}") do
+        time1 = PgTimestamp.new
+        time2 = PgTimestamp.new
+        assertEquals(time1.eql?(time2), true)
+        assertEquals(time1 == time2, true)
+        assertEquals(time1 != time2, false)
+        args = fields.collect do |f|
+          if f == field then 1 else 0 end
+        end
+        time2 = PgTimestamp.new(*args)
+        assertEquals(time1 == time2, false)
+        assertEquals(time1 != time2, true)
+        assertEquals(time1.eql?(Object.new), false)
+        assertEquals(time1 == Object.new, false)
+      end
+    end
+  end
+
+  def test_hash
+    count = 0
+    hashes = Hash.new(0)
+    testHash = proc { |*args|
+      assertEquals(PgTimestamp.new(*args).hash, PgTimestamp.new(*args).hash)
+      hashes[PgTimestamp.new(*args).hash] += 1
+      count += 1
+    }
+    for i in (0...10)
+      testHash.call(i, 0, 0, 0, 0, 0, 0)
+      testHash.call(0, i, 0, 0, 0, 0, 0)
+      testHash.call(0, 0, i, 0, 0, 0, 0)
+      testHash.call(0, 0, 0, i, 0, 0, 0)
+      testHash.call(0, 0, 0, 0, i, 0, 0)
+      testHash.call(0, 0, 0, 0, 0, i, 0)
+      testHash.call(0, 0, 0, 0, 0, 0, i)
+    end
+    assertGreaterOrEqual(hashes.size.to_f / count, 0.5)
+  end
+
+  def test_to_s
+    testCases = [
+      [[0, 0, 0, 0, 0, 0], "0000-00-00 00:00:00.00000"],
+      [[1999, 12, 31, 23, 59, 59], "1999-12-31 23:59:59.00000"],
+      [[1999, 12, 31, 23, 59, 59, 98765], "1999-12-31 23:59:59.98765"],
+    ]
+    for testCase in testCases
+      args, expected = *testCase
+      assertEquals(PgTimestamp.new(*args).to_s, expected)
+      assertEquals(PgTimestamp.new(*args).to_sql, "timestamp '#{expected}'")
+    end
+  end
+
+  def test_to_local_time
+    testCases = [
+      [1970, 1, 1, 0, 0, 0],
+      [1999, 12, 31, 23, 59, 59],
+    ]
+    for testCase in testCases
+      time = Time.local(*testCase)
+      assertEquals(PgTimestamp.new(*testCase).to_local_time, time)
+    end
+  end
+
+  def test_to_utc_time
+    testCases = [
+      [1970, 1, 1, 0, 0, 0],
+      [1999, 12, 31, 23, 59, 59],
+    ]
+    for testCase in testCases
+      time = Time.utc(*testCase)
+      assertEquals(PgTimestamp.new(*testCase).to_utc_time, time)
+    end
+  end
+
+  def test_from_sql
+    testCases = [
+      [1900, 1, 1, 0, 0, 0],
+      [1999, 12, 31, 23, 59, 59],
+      [1999, 12, 31, 23, 59, 59, 98765],
+    ]
+    for testCase in testCases
+      sql = "%04d-%02d-%02d %02d:%02d:%02d" % testCase[0..5]
+      if testCase[6]
+        sql += ".%6d" % testCase[6]
+      end
+      assertEquals(PgTimestamp.from_sql(sql), PgTimestamp.new(*testCase))
+    end
+  end
+
+end
+
+PgTimestampTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/RandomThings.rb

@@ -0,0 +1,25 @@
+module RandomThings
+
+  def randomString
+    rand.to_s
+  end
+  module_function :randomString
+
+  alias_method :randomWhatever, :randomString
+  module_function :randomWhatever
+
+  def randomInteger
+    rand(1000000)
+  end
+
+  def randomFloat
+    rand
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End: