geos-extensions 0.2.2 → 0.3.0

data/test/reader_tests.rb

@@ -2,7 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class GeosReaderTests < Test::Unit::TestCase
+class GeosReaderTests < MiniTest::Unit::TestCase
   include TestHelper
 
   def test_from_wkb_bin
@@ -181,4 +181,41 @@ class GeosReaderTests < Test::Unit::TestCase
 
     assert_equal('POINT (0 0)', Geos.read('BOX(0 0, 0 0)').to_wkt(:trim => true))
   end
+
+  def test_allowed
+    assert_raises(ArgumentError) do
+      Geos.read(Geos.read(POINT_WKT), :allowed => [])
+    end
+
+    assert_equal(
+      'POINT (10 10.01)',
+      Geos.read(POINT_WKT, :allowed => :wkt).to_wkt(:trim => true)
+    )
+  end
+
+  def test_allowed_array
+    assert_equal(
+      'POINT (10 10.01)',
+      Geos.read(POINT_WKT, :allowed => [ :wkt ]).to_wkt(:trim => true)
+    )
+  end
+
+  def test_excluded
+    assert_raises(ArgumentError) do
+      Geos.read(POINT_WKT, :excluded => :wkt)
+    end
+  end
+
+  def test_excluded_array
+    assert_raises(ArgumentError) do
+      Geos.read(POINT_WKT, :excluded => [ :wkt ])
+    end
+  end
+
+  def test_allowed_and_excluded
+    assert_raises(ArgumentError) do
+      Geos.read(POINT_WKT, :allowed => :wkt, :excluded => :wkt)
+    end
+  end
 end
+

data/test/test_helper.rb

@@ -1,33 +1,24 @@
 
-require 'rubygems'
-require 'test/unit'
-
-if ENV['TEST_ACTIVERECORD'] || defined?(IRB)
-  ACTIVERECORD_GEM_VERSION = ENV['ACTIVERECORD_GEM_VERSION'] || '~> 3.2.0'
-  gem 'activerecord', ACTIVERECORD_GEM_VERSION
-
-  POSTGIS_PATHS = [
-    ENV['POSTGIS_PATH'],
-    '/opt/local/share/postgresql*/contrib/postgis-*',
-    '/usr/share/postgresql*/contrib/postgis-*',
-    '/usr/pgsql-*/share/contrib/postgis-*',
-  ].compact
-
-  puts "Testing against ActiveRecord #{Gem.loaded_specs['activerecord'].version.to_s}"
-  require 'active_support'
-  require 'active_support/core_ext/module/aliasing'
-  require 'active_record'
-  require 'active_record/fixtures'
-  require 'logger'
-
-  if ActiveRecord::VERSION::STRING < '3.0'
-    require 'fake_arel'
+if RUBY_VERSION >= '1.9'
+  require 'simplecov'
+
+  SimpleCov.command_name('Unit Tests')
+  SimpleCov.start do
+    add_filter '/test/'
   end
 end
 
-require File.join(File.dirname(__FILE__), %w{ .. lib geos_extensions })
+require 'rubygems'
+require 'forwardable'
+require 'minitest/autorun'
+
+if RUBY_VERSION >= '1.9'
+  require 'minitest/reporters'
+end
+
+require File.join(File.dirname(__FILE__), %w{ .. lib geos-extensions })
 
-puts "Ruby version #{RUBY_VERSION} - #{RbConfig::CONFIG['RUBY_INSTALL_NAME']}"
+puts "Ruby version #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} - #{RbConfig::CONFIG['RUBY_INSTALL_NAME']}"
 puts "ffi version #{Gem.loaded_specs['ffi'].version}" if Gem.loaded_specs['ffi']
 puts "Geos library version #{Geos::VERSION}" if defined?(Geos::VERSION)
 puts "GEOS version #{Geos::GEOS_VERSION}"
@@ -36,115 +27,10 @@ if defined?(Geos::FFIGeos)
   puts "Using #{Geos::FFIGeos.geos_library_paths.join(', ')}"
 end
 
-if ENV['TEST_ACTIVERECORD'] || defined?(IRB)
-  ActiveRecord::Base.logger = Logger.new("debug.log") if ENV['ENABLE_LOGGER']
-  ActiveRecord::Base.configurations = {
-    'arunit' => {}
-  }
-
-  %w{
-    database.yml
-    local_database.yml
-  }.each do |file|
-    file = File.join('test', file)
-
-    next unless File.exists?(file)
-
-    configuration = YAML.load(File.read(file))
-
-    if configuration['arunit']
-      ActiveRecord::Base.configurations['arunit'].merge!(configuration['arunit'])
-    end
-
-    if defined?(JRUBY_VERSION) && configuration['jdbc']
-      ActiveRecord::Base.configurations['arunit'].merge!(configuration['jdbc'])
-    end
-  end
-
-  ActiveRecord::Base.establish_connection 'arunit'
-  ARBC = ActiveRecord::Base.connection
-
-  if postgresql_version = ARBC.select_rows('SELECT version()').first.first
-    puts "PostgreSQL info from version(): #{postgresql_version}"
-  end
-
-  puts "Checking for PostGIS install"
-  2.times do
-    begin
-      if postgis_version = Geos::ActiveRecord.POSTGIS[:lib]
-        puts "PostGIS info from postgis_full_version(): #{postgis_version}"
-        break
-      end
-    rescue ActiveRecord::StatementInvalid
-      puts "Trying to install PostGIS. If this doesn't work, you'll have to do this manually!"
-
-      plpgsql = ARBC.select_rows(%{SELECT count(*) FROM pg_language WHERE lanname = 'plpgsql'}).first.first.to_i
-      if plpgsql == 0
-        ARBC.execute(%{CREATE LANGUAGE plpgsql})
-      end
-
-      %w{
-        postgis.sql
-        spatial_ref_sys.sql
-      }.each do |file|
-        if !(found = Dir.glob(POSTGIS_PATHS).collect { |path|
-          File.join(path, file)
-        }.first)
-          puts "ERROR: Couldn't find #{file}. Try setting the POSTGIS_PATH to give us a hint!"
-          exit
-        else
-          ARBC.execute(File.read(found))
-        end
-      end
-    end
-  end
-
-  if !ARBC.table_exists?('foos')
-    ActiveRecord::Migration.create_table(:foos) do |t|
-      t.text :name
-    end
-
-    ARBC.execute(%{SELECT AddGeometryColumn('public', 'foos', 'the_geom', #{Geos::ActiveRecord.UNKNOWN_SRID}, 'GEOMETRY', 2)})
-    ARBC.execute(%{SELECT AddGeometryColumn('public', 'foos', 'the_other_geom', 4326, 'GEOMETRY', 2)})
-  end
-
-  if !ARBC.table_exists?('foo3ds')
-    ActiveRecord::Migration.create_table(:foo3ds) do |t|
-      t.text :name
-    end
-
-    ARBC.execute(%{SELECT AddGeometryColumn('public', 'foo3ds', 'the_geom', #{Geos::ActiveRecord.UNKNOWN_SRID}, 'GEOMETRY', 3)})
-    ARBC.execute(%{SELECT AddGeometryColumn('public', 'foo3ds', 'the_other_geom', 4326, 'GEOMETRY', 3)})
-  end
-
-  if !ARBC.table_exists?('foo_geographies')
-    ActiveRecord::Migration.create_table(:foo_geographies) do |t|
-      t.text :name
-      t.column :the_geom, :geography
-      t.column :the_other_geom, 'geography(Geometry, 4326)'
-    end
-  end
-
-  class Foo < ActiveRecord::Base
-    include Geos::ActiveRecord::SpatialColumns
-    create_spatial_column_accessors!
-  end
-
-  class Foo3d < ActiveRecord::Base
-    include Geos::ActiveRecord::SpatialColumns
-    create_spatial_column_accessors!
-  end
-
-  class FooGeography < ActiveRecord::Base
-    include Geos::ActiveRecord::SpatialColumns
-    create_spatial_column_accessors!
-  end
-end
-
 module TestHelper
+  DELTA_TOLERANCE = 1e-8
   POINT_WKT = 'POINT(10 10.01)'
   POINT_EWKT = 'SRID=4326; POINT(10 10.01)'
-  POINT_EWKT_WITH_DEFAULT = 'SRID=default; POINT(10 10.01)'
   POINT_WKB = "0101000000000000000000244085EB51B81E052440"
   POINT_WKB_BIN = "\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x40\x85\xEB\x51\xB8\x1E\x05\x24\x40"
   POINT_EWKB = "0101000020E6100000000000000000244085EB51B81E052440"
@@ -152,31 +38,31 @@ module TestHelper
   POINT_G_LAT_LNG = "(10.01, 10)"
   POINT_G_LAT_LNG_URL_VALUE = "10.01,10"
 
-  POLYGON_WKT = 'POLYGON((0 0, 1 1, 2.5 2.5, 5 5, 0 0))'
-  POLYGON_EWKT = 'SRID=4326; POLYGON((0 0, 1 1, 2.5 2.5, 5 5, 0 0))'
+  POLYGON_WKT = 'POLYGON((0 0, 0 1, 2.5 2.5, 5 2.5, 0 0))'
+  POLYGON_EWKT = 'SRID=4326; POLYGON((0 0, 0 1, 2.5 2.5, 5 2.5, 0 0))'
   POLYGON_WKB = "
-    0103000000010000000500000000000000000000000000000000000000000000000000F
-    03F000000000000F03F0000000000000440000000000000044000000000000014400000
-    00000000144000000000000000000000000000000000
+    01030000000100000005000000000000000000000000000000000000000000000000000
+    000000000000000F03F0000000000000440000000000000044000000000000014400000
+    00000000044000000000000000000000000000000000
   ".gsub(/\s/, '')
   POLYGON_WKB_BIN = [
     "\x01\x03\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00",
-    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xF0\x3F\x00",
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
     "\x00\x00\x00\x00\x00\xF0\x3F\x00\x00\x00\x00\x00\x00\x04\x40\x00\x00\x00\x00",
-    "\x00\x00\x04\x40\x00\x00\x00\x00\x00\x00\x14\x40\x00\x00\x00\x00\x00\x00\x14",
+    "\x00\x00\x04\x40\x00\x00\x00\x00\x00\x00\x14\x40\x00\x00\x00\x00\x00\x00\x04",
     "\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
   ].join
   POLYGON_EWKB = "
     0103000020E610000001000000050000000000000000000000000000000000000000000
-    0000000F03F000000000000F03F00000000000004400000000000000440000000000000
-    1440000000000000144000000000000000000000000000000000
+    00000000000000000000000F03F00000000000004400000000000000440000000000000
+    1440000000000000044000000000000000000000000000000000
   ".gsub(/\s/, '')
   POLYGON_EWKB_BIN = [
     "\x01\x03\x00\x00\x20\xE6\x10\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00",
     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
-    "\x00\x00\x00\x00\x00\xF0\x3F\x00\x00\x00\x00\x00\x00\xF0\x3F\x00\x00",
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xF0\x3F\x00\x00",
     "\x00\x00\x00\x00\x04\x40\x00\x00\x00\x00\x00\x00\x04\x40\x00\x00\x00",
-    "\x00\x00\x00\x14\x40\x00\x00\x00\x00\x00\x00\x14\x40\x00\x00\x00\x00",
+    "\x00\x00\x00\x14\x40\x00\x00\x00\x00\x00\x00\x04\x40\x00\x00\x00\x00",
     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
   ].join
 
@@ -200,9 +86,26 @@ module TestHelper
     POINT (9 0)
   )'
 
+  MULTIPOINT_WKT = "MULTIPOINT((0 0), (10 10))"
+
+  MULTIPOLYGON_WKT = "MULTIPOLYGON(
+    ((0 0, 5 0, 5 5, 0 5, 0 0),(4 4, 4 1, 1 1, 1 4, 4 4)),
+    ((10 10, 15 10, 15 15, 10 15, 10 10),(14 14, 14 11, 11 11, 11 14, 14 14))
+  )"
+
+  MULTILINESTRING_WKT = "MULTILINESTRING((-20 -20, 10 10), (0 0, 30 30))"
+
   BOUNDS_G_LAT_LNG = "((0.1, 0.1), (5.2, 5.2))"
   BOUNDS_G_LAT_LNG_URL_VALUE = '0.1,0.1,5.2,5.2'
 
+  if String.method_defined?(:force_encoding)
+    POINT_WKB_BIN.force_encoding('BINARY')
+    POINT_EWKB_BIN.force_encoding('BINARY')
+
+    POLYGON_WKB_BIN.force_encoding('BINARY')
+    POLYGON_EWKB_BIN.force_encoding('BINARY')
+  end
+
   def assert_saneness_of_point(point)
     assert_kind_of(Geos::Point, point)
     assert_equal(10.01, point.lat)
@@ -213,11 +116,16 @@ module TestHelper
     assert_kind_of(Geos::Polygon, polygon)
     cs = polygon.exterior_ring.coord_seq
     assert_equal([
-      [ 0, 0 ],
-      [ 1, 1 ],
+      [ 0.0, 0.0 ],
+      [ 0.0, 1.0 ],
       [ 2.5, 2.5 ],
-      [ 5, 5 ],
-      [ 0, 0 ]
+      [ 5.0, 2.5 ],
+      [ 0.0, 0.0 ]
     ], cs.to_a)
   end
 end
+
+if RUBY_VERSION >= '1.9'
+  MiniTest::Reporters.use!(MiniTest::Reporters::SpecReporter.new)
+end
+

data/test/writer_tests.rb

@@ -9,12 +9,23 @@ rescue LoadError
   # do nothing
 end
 
-class GeosWriterTests < Test::Unit::TestCase
+begin
+  require 'json'
+rescue LoadError
+  # do nothing
+end
+
+class GeosWriterTests < MiniTest::Unit::TestCase
   include TestHelper
 
   def initialize(*args)
     @point = Geos.read(POINT_EWKB)
     @polygon = Geos.read(POLYGON_EWKB)
+    @linestring = Geos.read(LINESTRING_WKT)
+    @multipoint = Geos.read(MULTIPOINT_WKT)
+    @multipolygon = Geos.read(MULTIPOLYGON_WKT)
+    @multilinestring = Geos.read(MULTILINESTRING_WKT)
+    @geometrycollection = Geos.read(GEOMETRYCOLLECTION_WKT)
     super(*args)
   end
 
@@ -77,7 +88,7 @@ class GeosWriterTests < Test::Unit::TestCase
   end
 
   def test_to_flickr_bbox
-    assert_equal('0.0,0.0,5.0,5.0', @polygon.to_flickr_bbox)
+    assert_equal('0.0,0.0,5.0,2.5', @polygon.to_flickr_bbox)
   end
 
   if defined?(Builder::XmlMarkup)
@@ -102,7 +113,7 @@ class GeosWriterTests < Test::Unit::TestCase
       })
       out.rewind
 
-      assert_equal("<Polygon id=\"\"><extrude>true</extrude><altitudeMode>relativeToGround</altitudeMode><outerBoundaryIs><LinearRing><coordinates>0.0,0.0 1.0,1.0 2.5,2.5 5.0,5.0 0.0,0.0</coordinates></LinearRing></outerBoundaryIs></Polygon>",
+      assert_equal("<Polygon id=\"\"><extrude>true</extrude><altitudeMode>relativeToGround</altitudeMode><outerBoundaryIs><LinearRing><coordinates>0.0,0.0 0.0,1.0 2.5,2.5 5.0,2.5 0.0,0.0</coordinates></LinearRing></outerBoundaryIs></Polygon>",
         out.read
       )
     end
@@ -156,11 +167,11 @@ class GeosWriterTests < Test::Unit::TestCase
       assert_equal({
         "type" => "LineString",
         "coordinates" => [
-          [0.0, 0.0],
-          [1.0, 1.0],
-          [2.5, 2.5],
-          [5.0, 5.0],
-          [0.0, 0.0]
+          [ 0.0, 0.0 ],
+          [ 0.0, 1.0 ],
+          [ 2.5, 2.5 ],
+          [ 5.0, 2.5 ],
+          [ 0.0, 0.0 ]
         ]
       }, JSON.load(json))
     end
@@ -174,9 +185,9 @@ class GeosWriterTests < Test::Unit::TestCase
         "coordinates" => [
           [
             [0.0, 0.0],
-            [1.0, 1.0],
+            [0.0, 1.0],
             [2.5, 2.5],
-            [5.0, 5.0],
+            [5.0, 2.5],
             [0.0, 0.0]
           ]
         ]
@@ -358,4 +369,312 @@ class GeosWriterTests < Test::Unit::TestCase
       }, JSON.load(collection.to_geojson(:interior_rings => false)))
     end
   end
+
+  def test_to_box2d
+    assert_equal("BOX(10.0 10.01, 10.0 10.01)", @point.to_box2d)
+    assert_equal("BOX(0.0 0.0, 5.0 2.5)", @polygon.to_box2d)
+    assert_equal("BOX(0.0 0.0, 10.0 10.0)", @linestring.to_box2d)
+    assert_equal("BOX(0.0 0.0, 10.0 10.0)", @multipoint.to_box2d)
+    assert_equal("BOX(0.0 0.0, 15.0 15.0)", @multipolygon.to_box2d)
+    assert_equal("BOX(-20.0 -20.0, 30.0 30.0)", @multilinestring.to_box2d)
+    assert_equal("BOX(0.0 0.0, 14.0 14.0)", @geometrycollection.to_box2d)
+  end
+
+  def test_as_json
+    assert_equal({
+      :type => "point",
+      :lat => 10.01,
+      :lng => 10.0
+    }, @point.as_json)
+
+    assert_equal({
+      :type => "polygon",
+      :encoded => true,
+      :polylines => [ {
+        :points => "??_ibE?_~cH_hgN?_hgN~ggN~po]",
+        :levels => "BBBBB",
+        :bounds => {
+          :sw => [ 0.0, 0.0 ],
+          :ne => [ 5.0, 2.5 ]
+        }
+      } ],
+      :options => {}
+    }, @polygon.as_json)
+
+    assert_equal({
+      :type => "polygon",
+      :encoded => false,
+      :polylines => [ {
+        :points => [ [ 0.0, 0.0 ],  [ 0.0, 1.0 ],  [ 2.5, 2.5 ],  [ 5.0, 2.5 ],  [ 0.0, 0.0 ] ],
+        :bounds => {
+          :sw => [ 0.0, 0.0 ],
+          :ne => [ 5.0, 2.5 ]
+        }
+      } ]
+    }, @polygon.as_json(:encoded => false))
+
+    assert_equal({
+      :type => "lineString",
+      :encoded => true,
+      :points => "??_qo]_qo]_qo]??_qo]",
+      :levels => "BBBB"
+    }, @linestring.as_json)
+
+    assert_equal({
+      :type => "lineString",
+      :encoded => false,
+      :points => [ [ 0.0, 0.0 ], [ 5.0, 5.0 ], [ 5.0, 10.0 ], [ 10.0, 10.0 ] ]
+    }, @linestring.as_json(:encoded => false))
+
+    assert_equal([ {
+      :type => "point",
+      :lat => 0.0,
+      :lng => 0.0
+    }, {
+      :type => "point",
+      :lat => 10.0,
+      :lng => 10.0
+    } ], @multipoint.as_json)
+
+    assert_equal([ {
+      :type => "polygon",
+      :encoded => true,
+      :polylines => [ {
+        :points => "???_qo]_qo]??~po]~po]?",
+        :levels => "BBBBB",
+        :bounds => {
+          :sw => [ 0.0, 0.0 ],
+          :ne => [ 5.0, 5.0 ]
+        }
+      } ],
+      :options => {}
+    }, {
+      :type => "polygon",
+      :encoded => true,
+      :polylines => [ {
+        :points => "_c`|@_c`|@?_qo]_qo]??~po]~po]?",
+        :levels => "BBBBB",
+        :bounds => {
+          :sw => [ 10.0, 10.0 ],
+          :ne => [ 15.0, 15.0 ]
+        }
+      } ],
+      :options => {}
+    } ], @multipolygon.as_json)
+
+    assert_equal([ {
+      :type => "polygon",
+      :encoded => false,
+      :polylines => [ {
+        :points => [ [ 0.0, 0.0 ], [ 5.0, 0.0 ], [ 5.0, 5.0 ], [ 0.0, 5.0 ], [ 0.0, 0.0 ] ],
+        :bounds => {
+          :sw => [ 0.0, 0.0 ],
+          :ne => [ 5.0, 5.0 ]
+        }
+      } ]
+    }, {
+      :type => "polygon",
+      :encoded => false,
+      :polylines => [ {
+        :points => [ [ 10.0, 10.0 ], [ 15.0, 10.0 ], [ 15.0, 15.0 ], [ 10.0, 15.0 ], [ 10.0, 10.0 ] ],
+        :bounds => {
+          :sw => [ 10.0, 10.0 ],
+          :ne => [ 15.0, 15.0 ]
+        }
+      } ]
+    } ], @multipolygon.as_json(:encoded => false))
+
+    assert_equal([ {
+      :type => "lineString",
+      :encoded => true,
+      :points => "~fayB~fayB_kbvD_kbvD",
+      :levels => "BB"
+    }, {
+      :type => "lineString",
+      :encoded => true,
+      :points => "??_kbvD_kbvD",
+      :levels => "BB"
+    } ], @multilinestring.as_json)
+
+    assert_equal([{
+      :type => "lineString",
+      :encoded => false,
+      :points => [ [ -20.0, -20.0 ], [ 10.0, 10.0 ] ]
+    }, {
+      :type => "lineString",
+      :encoded => false,
+      :points => [ [ 0.0, 0.0 ], [ 30.0, 30.0 ] ]
+    } ], @multilinestring.as_json(:encoded => false))
+
+    assert_equal([
+      [ {
+        :type => "polygon",
+        :encoded => true,
+        :polylines => [ {
+          :points => "???_ibE_ibE??~hbE~hbE?",
+          :levels => "BBBBB",
+          :bounds => {
+            :sw => [ 0.0, 0.0 ],
+            :ne => [ 1.0, 1.0 ]
+          }
+        } ],
+        :options => {}
+      }, {
+        :type => "polygon",
+        :encoded => true,
+        :polylines => [ {
+          :points => "_c`|@_c`|@_glW??_glW~flW??~flW",
+          :levels => "BBBBB",
+          :bounds => {
+            :sw => [ 10.0, 10.0 ],
+            :ne => [ 14.0, 14.0 ]
+          }
+        } ],
+        :options => {}
+      } ],
+
+      {
+        :type => "polygon",
+        :encoded => true,
+        :polylines => [ {
+          :points => "???_ibE_ibE??~hbE~hbE?",
+          :levels => "BBBBB",
+          :bounds => {
+            :sw => [ 0.0, 0.0 ],
+            :ne => [ 1.0, 1.0 ]
+          }
+        } ],
+        :options => {}
+      }, {
+        :type => "polygon",
+        :encoded => true,
+        :polylines => [ {
+          :points => "???_qo]_qo]??~po]~po]?",
+          :levels => "BBBBB",
+          :bounds => {
+            :sw => [ 0.0, 0.0 ],
+            :ne => [ 5.0, 5.0 ]
+          }
+        } ],
+        :options => {}
+      },
+
+      [ {
+        :type => "lineString",
+        :encoded => true,
+        :points => "??_}hQ_seK",
+        :levels => "BB"
+      }, {
+        :type => "lineString",
+        :encoded => true,
+        :points => "_c`|@_c`|@~zrc@~dvi@",
+        :levels => "BB"
+      } ],
+
+      {
+        :type => "lineString",
+        :encoded => true,
+        :points => "??_}hQ_seK",
+        :levels => "BB"
+      },
+
+      [ {
+        :type => "point",
+        :lat => 0.0,
+        :lng => 0.0
+      }, {
+        :type => "point",
+        :lat => 3.0,
+        :lng => 2.0
+      } ],
+
+      {
+        :type => "point",
+        :lat => 0.0,
+        :lng => 9.0
+      }
+    ], @geometrycollection.as_json)
+
+    assert_equal([
+      [ {
+        :type => "polygon",
+        :encoded => false,
+        :polylines => [ {
+          :points => [ [ 0.0, 0.0], [ 1.0, 0.0], [ 1.0, 1.0], [ 0.0, 1.0], [ 0.0, 0.0 ] ],
+          :bounds => {
+            :sw => [ 0.0, 0.0 ],
+            :ne => [ 1.0, 1.0 ]
+          }
+        } ]
+      },
+
+      {
+        :type => "polygon",
+        :encoded => false,
+        :polylines => [ {
+          :points => [ [ 10.0, 10.0 ], [ 10.0, 14.0 ], [ 14.0, 14.0 ], [ 14.0, 10.0 ], [ 10.0, 10.0 ] ],
+          :bounds => {
+            :sw => [ 10.0, 10.0 ],
+            :ne => [ 14.0, 14.0 ]
+          }
+        } ]
+      } ],
+
+      {
+        :type => "polygon",
+        :encoded => false,
+        :polylines => [ {
+          :points => [ [ 0.0, 0.0 ], [ 1.0, 0.0 ], [ 1.0, 1.0 ], [ 0.0, 1.0 ], [ 0.0, 0.0 ] ],
+          :bounds => {
+            :sw => [ 0.0, 0.0 ],
+            :ne => [ 1.0, 1.0 ]
+          }
+        } ]
+      },
+
+      {
+        :type => "polygon",
+        :encoded => false,
+        :polylines => [ {
+          :points => [ [ 0.0, 0.0 ], [ 5.0, 0.0 ], [ 5.0, 5.0 ], [ 0.0, 5.0 ], [ 0.0, 0.0 ] ],
+          :bounds => {
+            :sw => [ 0.0, 0.0 ],
+            :ne => [ 5.0, 5.0 ]
+          }
+        } ]
+      },
+
+      [ {
+        :type => "lineString",
+        :encoded => false,
+        :points => [ [ 0.0, 0.0 ], [ 2.0, 3.0 ] ]
+      }, {
+        :type => "lineString",
+        :encoded => false,
+        :points => [ [ 10.0, 10.0 ], [ 3.0, 4.0 ] ]
+      } ],
+
+      {
+        :type => "lineString",
+        :encoded => false,
+        :points => [ [ 0.0, 0.0 ], [ 2.0, 3.0 ] ]
+      },
+
+      [ {
+        :type => "point",
+        :lat => 0.0,
+        :lng => 0.0
+      }, {
+        :type => "point",
+        :lat => 3.0,
+        :lng => 2.0
+      } ],
+
+      {
+        :type => "point",
+        :lat => 0.0,
+        :lng => 9.0
+      }
+    ], @geometrycollection.as_json(:encoded => false))
+  end
 end