sqlpostgres 1.2.4

data/test/PgCidr.test.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+require 'RandomThings'
+
+class PgCidrTest < Test
+
+  include SqlPostgres
+  include RandomThings
+
+  def test
+    ipAndMask = randomString
+    assertEquals(PgCidr.from_sql(ipAndMask), PgCidr.new(ipAndMask))
+    assertEquals(PgCidr.new(ipAndMask).to_s, ipAndMask)
+    assertEquals(PgCidr.new(ipAndMask).to_sql, "cidr '#{ipAndMask}'")
+  end
+
+  def test_equality
+    testCases = [
+      ["a", "a", true],
+      ["a", "b", false],
+      ["b", "a", false],
+    ]
+    for testCase in testCases
+      assertInfo("For test case #{testCase.inspect}") do
+        argA, argB, equal = *testCase
+        a = PgCidr.new(argA)
+        b = PgCidr.new(argB)
+        assertEquals(a == b, equal)
+        assertEquals(a.eql?(b), equal)
+        assertEquals(a != b, !equal)
+      end
+    end
+  end
+
+  def test_hash
+    count = 0
+    hashes = Hash.new(0)
+    testHash = proc { |*args|
+      assertEquals(PgCidr.new(*args).hash, PgCidr.new(*args).hash)
+      hashes[PgCidr.new(*args).hash] += 1
+      count += 1
+    }
+    for i in (0...10)
+      testHash.call(i.to_s)
+    end
+    assertGreaterOrEqual(hashes.size.to_f / count, 0.5)
+  end
+
+end
+
+PgCidrTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/PgCircle.test.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+require 'RandomThings'
+
+class PgCircleTest < Test
+
+  include SqlPostgres
+  include RandomThings
+
+  def test_ctor_defaults
+    assertEquals(PgCircle.new, PgCircle.new(0, 0, 0))
+  end
+
+  def test_ctor_and_accessors
+    x = randomFloat
+    y = randomFloat
+    radius = randomFloat
+    circle = PgCircle.new(x, y, radius)
+    assertEquals(circle.center, PgPoint.new(x, y))
+    assertEquals(circle.radius, radius)
+    circle = PgCircle.new(PgPoint.new(x, y), radius)
+    assertEquals(circle.center, PgPoint.new(x, y))
+    assertEquals(circle.radius, radius)
+    assertException(ArgumentError, "Incorrect number of arguments: 1") do
+      PgCircle.new(1)
+    end
+  end
+
+  def test_from_sql
+    testCases = [
+      ["<(1,2),3>", [1, 2, 3]],
+      ["<(1,2.3),1e+30>", [1, 2.3, 1e30]],
+    ]
+    for testCase in testCases
+      sql, args = *testCase
+      assertInfo("For sql #{sql.inspect}") do
+        assertEquals(PgCircle.from_sql(sql), PgCircle.new(*args))
+      end
+    end
+    assertException(ArgumentError, 'Invalid circle: "foo"') do
+      PgCircle.from_sql("foo")
+    end
+  end
+
+  def test_equality
+    fields = ["center", "radius"]
+    for field in fields
+      assertInfo("For field #{field}") do
+        circle1 = PgCircle.new
+        circle2 = PgCircle.new
+        assertEquals(circle1.eql?(circle2), true)
+        assertEquals(circle1 == circle2, true)
+        assertEquals(circle1 != circle2, false)
+        args = fields.collect do |f|
+          if f == field then 1 else 0 end
+        end
+        circle2 = PgCircle.new(*args)
+        assertEquals(circle1 == circle2, false)
+        assertEquals(circle1 != circle2, true)
+        assertEquals(circle1.eql?(Object.new), false)
+        assertEquals(circle1 == Object.new, false)
+      end
+    end
+  end
+
+  def test_hash
+    count = 0
+    hashes = Hash.new(0)
+    testHash = proc { |*args|
+      assertEquals(PgCircle.new(*args).hash, PgCircle.new(*args).hash)
+      hashes[PgCircle.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], "<(0, 0), 0>"],
+      [[1.2, -2, 1e10], "<(1.2, -2), 1e+10>"],
+    ]
+    for testCase in testCases
+      args, expected = *testCase
+      circle = PgCircle.new(*args)
+      assertEquals(circle.to_s, expected)
+      assertEquals(circle.to_sql, "circle '#{expected}'")
+    end
+  end
+
+end
+
+PgCircleTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/PgInet.test.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+require 'RandomThings'
+
+class PgInetTest < Test
+
+  include SqlPostgres
+  include RandomThings
+
+  def test
+    ipAndMask = randomString
+    assertEquals(PgInet.new(ipAndMask), PgInet.from_sql(ipAndMask))
+    assertEquals(PgInet.new(ipAndMask).to_s, ipAndMask)
+    assertEquals(PgInet.new(ipAndMask).to_sql, "inet '#{ipAndMask}'")
+  end
+
+  def test_equality
+    testCases = [
+      ["a", "a", true],
+      ["a", "b", false],
+      ["b", "a", false],
+    ]
+    for testCase in testCases
+      assertInfo("For test case #{testCase.inspect}") do
+        argA, argB, equal = *testCase
+        a = PgInet.new(argA)
+        b = PgInet.new(argB)
+        assertEquals(a == b, equal)
+        assertEquals(a.eql?(b), equal)
+        assertEquals(a != b, !equal)
+      end
+    end
+  end
+
+  def test_hash
+    count = 0
+    hashes = Hash.new(0)
+    testHash = proc { |*args|
+      assertEquals(PgInet.new(*args).hash, PgInet.new(*args).hash)
+      hashes[PgInet.new(*args).hash] += 1
+      count += 1
+    }
+    for i in (0...10)
+      testHash.call(i.to_s)
+    end
+    assertGreaterOrEqual(hashes.size.to_f / count, 0.5)
+  end
+
+end
+
+PgInetTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/PgInterval.test.rb

@@ -0,0 +1,180 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+require 'RandomThings'
+
+class PgIntervalTest < Test
+
+  include SqlPostgres
+  include RandomThings
+
+  FIELDS = [
+    "millennia", "centuries", "decades",
+    "years", "months", "days", "weeks",
+    "hours", "minutes", "seconds",
+    "ago"
+  ]
+
+  def test_ctor_and_accessors
+    for ago in [false, true]
+      args = Hash[*FIELDS.collect do |field| 
+          [field, randomInteger] 
+        end.flatten]
+      args['ago'] = ago
+      interval = PgInterval.new(args)
+      assertInfo("For ago=#{ago}") do
+        for field, value in args
+          assertInfo("For field=#{field}") do
+            assertEquals(interval.send(field), value)
+          end
+          assertEquals(interval.ago, ago)
+        end
+      end
+    end
+  end
+
+  def test_ctor_invlaid_args
+    assertException(ArgumentError, '{"foo"=>1}') do
+      PgInterval.new('foo'=>1)
+    end
+  end
+
+  def test_ctor_defaults
+    args = Hash[*FIELDS.collect do |field| 
+        [field, field == 'ago' ? false : 0] 
+      end.flatten]
+    assertEquals(PgInterval.new, PgInterval.new(args))
+  end
+
+  def test_equality
+    for field in FIELDS
+      assertInfo("For field #{field}") do
+        time1 = PgInterval.new
+        time2 = PgInterval.new
+        assertEquals(time1.eql?(time2), true)
+        assertEquals(time1 == time2, true)
+        assertEquals(time1 != time2, false)
+        time2 = PgInterval.new(field=>1)
+        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)
+    for i in (0...9)
+      for field in FIELDS
+        args = {field=>i}
+        assertEquals(PgInterval.new(args).hash, PgInterval.new(args).hash)
+        hashes[PgInterval.new(args).hash] += 1
+        count += 1
+      end
+    end
+    assertGreaterOrEqual(hashes.size.to_f / count, 0.5)
+  end
+
+  def test_to_s
+    testCases = [
+      [{}, "0 days"],
+      [{"seconds"=>2}, "00:00:02"],
+      [{"minutes"=>2}, "00:02"],
+      [{"hours"=>2}, "02:00"],
+      [{"hours"=>1, "minutes"=>2, "seconds"=>3}, "01:02:03"],
+      [{"days"=>2}, "2 days"],
+      [{"weeks"=>2}, "2 weeks"],
+      [{"months"=>2}, "2 months"],
+      [{"years"=>2}, "2 years"],
+      [{"decades"=>2}, "2 decades"],
+      [{"centuries"=>2}, "2 centuries"],
+      [{"millennia"=>2}, "2 millennia"],
+      [{"seconds"=>1}, "00:00:01"],
+      [{"minutes"=>1}, "00:01"],
+      [{"hours"=>1}, "01:00"],
+      [{"days"=>1}, "1 day"],
+      [{"weeks"=>1}, "1 week"],
+      [{"months"=>1}, "1 month"],
+      [{"years"=>1}, "1 year"],
+      [{"decades"=>1}, "1 decade"],
+      [{"centuries"=>1}, "1 century"],
+      [{"millennia"=>1}, "1 millennium"],
+      [{"years"=>1, "days"=>2}, "1 year 2 days"],
+      [ {
+          'centuries'=>2, 'decades'=>3, 'years'=>4, 'months'=>5,
+          'weeks'=>6, 'days'=>7, 'hours'=>8, 'minutes'=>9, 'seconds'=>10
+        },
+        "2 centuries 3 decades 4 years 5 months 6 weeks 7 days 08:09:10"
+      ],
+      [{"days"=>1, "ago"=>false}, "1 day"],
+      [{"days"=>1, "ago"=>true}, "1 day ago"],
+      [{"days"=>-1}, "-1 days"],
+      [{"days"=>-1, "ago"=>true}, "-1 days ago"],
+      [{"ago"=>true}, "0 days ago"],
+      [{"seconds"=>1.123456}, "00:00:01.123456"],
+      [{"seconds"=>59.999999}, "00:00:59.999999"],
+      [{"hours"=>1, "minutes"=>1, "seconds"=>1}, "01:01:01"],
+      [{"hours"=>-1, "minutes"=>-1, "seconds"=>-1}, "-01:01:01"],
+      [
+        {"hours"=>1, "minutes"=>-1, "seconds"=>1}, 
+        "1 hour -1 minutes 1 second"
+      ],
+    ]
+    for args, expected in testCases
+      assertInfo("For args=#{args.inspect}") do
+        assertEquals(PgInterval.new(args).to_s, expected)
+        assertEquals(PgInterval.new(args).to_sql, "interval '#{expected}'")
+      end
+    end
+  end
+
+  def test_from_sql
+    testCases = [
+      ["00:00", PgInterval.new],
+      ["01:02", PgInterval.new('hours'=>1, 'minutes'=>2)],
+      ["01:02:03", PgInterval.new('hours'=>1, 'minutes'=>2, 'seconds'=>3)],
+      ["-01:02:03", PgInterval.new('hours'=>-1, 'minutes'=>-2, 'seconds'=>-3)],
+      ["1 day", PgInterval.new('days'=>1)],
+      ["2 days", PgInterval.new('days'=>2)],
+      ["2 days 03:00", PgInterval.new('days'=>2, 'hours'=>3)],
+      ["1 mon", PgInterval.new('months'=>1)],
+      ["2 mons", PgInterval.new('months'=>2)],
+      ["00:00:01.100000", PgInterval.new('seconds'=>1.1)],
+    ]
+    for sql, interval in testCases
+      assertInfo("For sql=#{sql.inspect}") do
+        assertEquals(PgInterval.from_sql(sql), interval)
+      end
+    end
+  end
+
+  def test_from_sql_exceptions
+    testCases = [
+      "",
+      "1 foo",
+      "foo",
+    ]
+    for sql in testCases
+      assertInfo("For sql=#{sql.inspect}") do
+        message = "Syntax error in interval: #{sql.inspect}"
+        assertException(ArgumentError, message) do
+          PgInterval.from_sql(sql)
+        end
+      end
+    end
+  end
+
+end
+
+PgIntervalTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/PgLineSegment.test.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+require 'RandomThings'
+
+class PgLineSegmentTest < Test
+
+  include SqlPostgres
+  include RandomThings
+
+   def test_ctor_defaults
+     assertEquals(PgLineSegment.new, PgLineSegment.new(PgPoint.new, PgPoint.new))
+   end
+
+  def test_ctor_and_accessors
+    p1 = randomWhatever
+    p2 = randomWhatever
+    line = PgLineSegment.new(p1, p2)
+    assertEquals(line.p1, p1)
+    assertEquals(line.p2, p2)
+
+    x1 = randomFloat
+    x2 = randomFloat
+    y1 = randomFloat
+    y2 = randomFloat
+    line = PgLineSegment.new(x1, y1, x2, y2)
+    assertEquals(line.p1, PgPoint.new(x1, y1))
+    assertEquals(line.p2, PgPoint.new(x2, y2))
+  end
+
+  def test_from_sql
+    testCases = [
+      ["[(0,0),(0,0)]", [0, 0, 0, 0]],
+      ["[(1.2,-3),(1e+20,-1e20)]", [1.2, -3, 1e+20, -1e20]],
+    ]
+    for testCase in testCases
+      sql, args = *testCase
+      assertInfo("For sql #{sql.inspect}") do
+        assertEquals(PgLineSegment.from_sql(sql), PgLineSegment.new(*args))
+      end
+    end
+    assertException(ArgumentError, 'Invalid lseg: "foo"') do
+      PgLineSegment.from_sql("foo")
+    end
+  end
+
+  def test_equality
+    fields = ["p1", "p2"]
+    for field in fields
+      assertInfo("For field #{field}") do
+        line1 = PgLineSegment.new
+        line2 = PgLineSegment.new
+        assertEquals(line1.eql?(line2), true)
+        assertEquals(line1 == line2, true)
+        assertEquals(line1 != line2, false)
+        args = fields.collect do |f|
+          if f == field then 1 else 0 end
+        end
+        line2 = PgLineSegment.new(*args)
+        assertEquals(line1 == line2, false)
+        assertEquals(line1 != line2, true)
+        assertEquals(line1.eql?(Object.new), false)
+        assertEquals(line1 == Object.new, false)
+      end
+    end
+  end
+
+  def test_hash
+    count = 0
+    hashes = Hash.new(0)
+    testHash = proc { |*args|
+      assertEquals(PgLineSegment.new(*args).hash, PgLineSegment.new(*args).hash)
+      hashes[PgLineSegment.new(*args).hash] += 1
+      count += 1
+    }
+    for i in (0...10)
+      testHash.call(i, 0, 0, 0)
+      testHash.call(0, i, 0, 0)
+      testHash.call(0, 0, i, 0)
+      testHash.call(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), (0, 0))"],
+      [[1.2, -2, 1e10, -1e10], "((1.2, -2), (1e+10, -1e+10))"],
+    ]
+    for testCase in testCases
+      args, expected = *testCase
+      assertEquals(PgLineSegment.new(*args).to_s, expected)
+      assertEquals(PgLineSegment.new(*args).to_sql, "lseg '#{expected}'")
+    end
+  end
+
+end
+
+PgLineSegmentTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/PgMacAddr.test.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+require 'RandomThings'
+
+class PgMacAddrTest < Test
+
+  include SqlPostgres
+  include RandomThings
+
+  def test
+    ipAndMask = randomString
+    assertEquals(PgMacAddr.from_sql(ipAndMask), PgMacAddr.new(ipAndMask))
+    assertEquals(PgMacAddr.new(ipAndMask).to_s, ipAndMask)
+    assertEquals(PgMacAddr.new(ipAndMask).to_sql, "macaddr '#{ipAndMask}'")
+  end
+
+  def test_equality
+    testCases = [
+      ["a", "a", true],
+      ["a", "b", false],
+      ["b", "a", false],
+    ]
+    for testCase in testCases
+      assertInfo("For test case #{testCase.inspect}") do
+        argA, argB, equal = *testCase
+        a = PgMacAddr.new(argA)
+        b = PgMacAddr.new(argB)
+        assertEquals(a == b, equal)
+        assertEquals(a.eql?(b), equal)
+        assertEquals(a != b, !equal)
+      end
+    end
+  end
+
+  def test_hash
+    count = 0
+    hashes = Hash.new(0)
+    testHash = proc { |*args|
+      assertEquals(PgMacAddr.new(*args).hash, PgMacAddr.new(*args).hash)
+      hashes[PgMacAddr.new(*args).hash] += 1
+      count += 1
+    }
+    for i in (0...10)
+      testHash.call(i.to_s)
+    end
+    assertGreaterOrEqual(hashes.size.to_f / count, 0.5)
+  end
+
+end
+
+PgMacAddrTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/PgPath.test.rb

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