ruby_mapnik 0.1

data/test/data/test_map.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Map srs="+proj=latlong +datum=WGS84" background-color="rgb(0,0,255)">
+  <Style name="My Style">
+    <Rule>
+      <PolygonSymbolizer fill="rgb(255,0,0)"/>
+    </Rule>
+  </Style>
+  <Layer name="world" srs="+proj=latlong +datum=WGS84">
+    <StyleName>My Style</StyleName>
+    <Datasource>
+      <Parameter name="file">TM_WORLD_BORDERS_SIMPL_0.3_MOD</Parameter>
+      <Parameter name="type">shape</Parameter>
+    </Datasource>
+  </Layer>
+</Map>

data/test/test_helper.rb

@@ -0,0 +1,27 @@
+=begin 
+ ******************************************************************************
+ * 
+ * Copyright (C) 2011 Elliot Laster
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ ******************************************************************************
+=end
+require "test/unit"
+require "ruby_mapnik"
+
+unless defined?(SHAPEFILE)
+  SHAPEFILE = "#{File.expand_path(File.dirname(__FILE__))}/data/TM_WORLD_BORDERS_SIMPL_0.3_MOD"
+end

data/test/test_line_pattern_symbolizer.rb

@@ -0,0 +1,26 @@
+require "test_helper"
+
+class TestLinePatternSymbolizer < Test::Unit::TestCase
+  
+  def setup
+    @filename = "/my/file.png"
+    path_expression = Mapnik::PathExpression.parse("/my/file.png")
+    @sym = Mapnik::LinePatternSymbolizer.new(path_expression)
+  end
+  
+  def test_presence
+    assert Mapnik::LinePatternSymbolizer
+  end
+  
+  def test_should_instantiate
+    assert @sym
+  end
+  
+  def test_should_get_and_set_filename
+    assert_equal @filename, @sym.filename
+    new_filename = "/something/else.png"
+    @sym.filename = new_filename
+    assert_equal new_filename, @sym.filename
+  end
+  
+end

data/test/test_mapnik_color.rb

@@ -0,0 +1,66 @@
+=begin 
+ ******************************************************************************
+ * 
+ * Copyright (C) 2011 Elliot Laster
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ ******************************************************************************
+=end
+require 'test_helper'
+class TestMapnikColor < Test::Unit::TestCase
+  
+  def test_should_instantiate_and_update_values
+    values = {:red => 0, :green => 0, :blue => 0, :alpha => 0}
+    color = Mapnik::Color.new("#000")
+    color.alpha = 0
+    values.each do |key, value|
+      assert_equal(value, color.send("#{key}"))
+      color.send("#{key}=", value + 1)
+      assert_equal(value + 1, color.send("#{key}"))
+    end
+    
+  end
+  
+  def test_should_instantiate_with_a_css_hex_value
+    color = Mapnik::Color.new("#ff0000")
+    assert_equal 255, color.red
+    assert_equal 0, color.green
+    assert_equal 0, color.blue
+  end
+  
+  def test_should_instantiate_with_a_rgb_value
+    red = 34
+    green = 120
+    blue = 134
+    color = Mapnik::Color.new(red, green, blue)
+    assert_equal red, color.red
+    assert_equal green, color.green
+    assert_equal blue, color.blue
+  end
+  
+  def test_should_instantiate_with_a_rgba_value
+    red = 34
+    green = 120
+    blue = 134
+    alpha = 0
+    color = Mapnik::Color.new(red, green, blue, alpha)
+    assert_equal red, color.red
+    assert_equal green, color.green
+    assert_equal blue, color.blue
+    assert_equal alpha, color.alpha
+  end
+  
+end

data/test/test_mapnik_coord.rb

@@ -0,0 +1,112 @@
+=begin 
+ ******************************************************************************
+ * 
+ * Copyright (C) 2011 Elliot Laster
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ ******************************************************************************
+=end
+require 'test_helper'
+class TestMapnikCoord < Test::Unit::TestCase
+  
+  def test_should_hang_onto_and_update_values
+    coord2d = Mapnik::Coord2d.new(1, 2)
+    assert_equal(1, coord2d.x)
+    assert_equal(2, coord2d.y)
+    
+    coord2d.x = 2
+    coord2d.y = 4
+    assert_equal(2, coord2d.x)
+    assert_equal(4, coord2d.y)
+  end
+  
+  def test_should_be_equal_to_another_coord_if_the_x_and_ys_match
+    coord2d = Mapnik::Coord2d.new(1,2)
+    other_coord = Mapnik::Coord2d.new(coord2d.x, coord2d.y)
+    assert other_coord.object_id != coord2d.object_id
+    assert_equal(other_coord.x, coord2d.x)
+    assert_equal(other_coord.y, coord2d.y)
+    assert_equal(other_coord, coord2d)
+    
+    other_coord.x += 3
+    assert_not_equal(other_coord, coord2d)
+    other_coord.x = coord2d.x
+    assert_equal(other_coord, coord2d)
+    
+    other_coord.y += 3
+    assert_not_equal(other_coord, coord2d)
+    other_coord.y = coord2d.y
+    assert_equal(other_coord, coord2d)
+    
+    other_coord.x += 3
+    other_coord.y += 3
+    assert_not_equal(other_coord, coord2d)
+  end
+  
+  # These could be refactored, I suppose...
+  def test_should_return_a_new_coord_when_multiplied_by_a_number
+    start_x = 1
+    start_y = 2
+    factor  = 3
+    coord2d = Mapnik::Coord2d.new(start_x, start_y)
+    multiplied_coord = coord2d * factor
+    assert_not_equal(coord2d.object_id, multiplied_coord.object_id)
+    assert_equal(coord2d.x * factor, multiplied_coord.x)
+    assert_equal(coord2d.y * factor, multiplied_coord.y)
+    assert_equal(coord2d.x, start_x)
+    assert_equal(coord2d.y, start_y)
+  end
+  
+  def test_should_return_a_new_coord_when_added_to_by_a_number
+    start_x = 1
+    start_y = 2
+    factor  = 3
+    coord2d = Mapnik::Coord2d.new(start_x, start_y)
+    added_coord = coord2d + factor
+    assert_not_equal(coord2d.object_id, added_coord.object_id)
+    assert_equal(coord2d.x + factor, added_coord.x)
+    assert_equal(coord2d.y + factor, added_coord.y)
+    assert_equal(coord2d.x, start_x)
+    assert_equal(coord2d.y, start_y)
+  end
+  
+  def test_should_return_a_new_coord_when_subtracted_from_by_a_number
+    start_x = 1
+    start_y = 2
+    factor  = 3
+    coord2d = Mapnik::Coord2d.new(start_x, start_y)
+    subtracted_coord = coord2d - factor
+    assert_not_equal(coord2d.object_id, subtracted_coord.object_id)
+    assert_equal(coord2d.x - factor, subtracted_coord.x)
+    assert_equal(coord2d.y - factor, subtracted_coord.y)
+    assert_equal(coord2d.x, start_x)
+    assert_equal(coord2d.y, start_y)
+  end
+  
+  def test_should_return_a_new_coord_when_divided_by_a_number
+    start_x = 1
+    start_y = 2
+    factor  = 3
+    coord2d = Mapnik::Coord2d.new(start_x, start_y)
+    divided_coord = coord2d / factor
+    assert_not_equal(coord2d.object_id, divided_coord.object_id)
+    assert_equal(coord2d.x / factor, divided_coord.x)
+    assert_equal(coord2d.y / factor, divided_coord.y)
+    assert_equal(coord2d.x, start_x)
+    assert_equal(coord2d.y, start_y)
+  end
+  
+end

data/test/test_mapnik_datasource.rb

@@ -0,0 +1,49 @@
+=begin 
+ ******************************************************************************
+ * 
+ * Copyright (C) 2011 Elliot Laster
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ ******************************************************************************
+=end
+require 'test_helper'
+class TestMapnikDatasource < Test::Unit::TestCase
+  
+  def setup
+    @datasource_params = {
+      :type => 'shape',
+      :file => SHAPEFILE
+    }
+    @datasource = Mapnik::Datasource.create(@datasource_params)
+  end
+  
+  def test_should_create_a_new_datasource
+    assert @datasource
+  end
+  
+  def test_should_have_an_envelope
+    assert @datasource.envelope.kind_of?(Mapnik::Envelope)
+  end
+
+  # def test_should_have_a_descriptor
+  #   raise @datasource.descriptor.inspect
+  # end
+
+  def test_should_get_params
+    assert_equal @datasource_params, @datasource.params
+  end
+
+end

data/test/test_mapnik_envelope.rb

@@ -0,0 +1,232 @@
+=begin 
+ ******************************************************************************
+ * 
+ * Copyright (C) 2011 Elliot Laster
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ ******************************************************************************
+=end
+require "test_helper"
+
+class TestMapnikEnvelope < Test::Unit::TestCase
+  
+  def test_presence
+    assert Mapnik::Envelope
+  end
+  
+  def test_should_instantiate
+    assert Mapnik::Envelope.new(1,1,5,5)
+  end
+  
+  def test_should_set_attributes_correctly
+    min_x = 1
+    min_y = 2
+    max_x = 3
+    max_y = 4
+    envelope = Mapnik::Envelope.new(min_x, min_y, max_x, max_y)
+    assert_equal(min_x, envelope.min_x)
+    assert_equal(min_y, envelope.min_y)
+    assert_equal(max_x, envelope.max_x)
+    assert_equal(max_y, envelope.max_y)
+  end
+  
+  def test_equality
+    envelope1 = Mapnik::Envelope.new(0, 0, 10, 10)
+    envelope2 = Mapnik::Envelope.new(0, 0, 10, 10)
+    assert_equal(envelope1, envelope2)
+    envelope1.re_center_to_xy!(7, 7)
+    assert_not_equal(envelope1, envelope2)
+    envelope1.re_center_to_coord!(envelope2.center)
+    assert_equal(envelope1, envelope2)
+  end
+  
+  def test_should_return_center
+    envelope = Mapnik::Envelope.new(0, 0, 100, 50)
+    assert center = envelope.center
+    assert_equal 50, center.x
+    assert_equal 25, center.y
+  end
+  
+  def test_should_return_height
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    assert_equal(10, envelope.height)
+  end
+  
+  def test_should_update_height
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    assert_equal(10, envelope.height)
+    envelope.height = 20
+    assert_equal 20, envelope.height
+    assert_equal 15, envelope.max_y
+    assert_equal(-5, envelope.min_y)
+  end
+  
+  def test_should_return_width
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    assert_equal(10, envelope.width)
+  end
+  
+  def test_should_update_width
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    assert_equal(10, envelope.width)
+    envelope.width = 20
+    assert_equal 20, envelope.width
+    assert_equal 15, envelope.max_x
+    assert_equal(-5, envelope.min_x)
+  end
+  
+  def test_should_recenter_to_xy
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    assert_equal 5, envelope.center.x
+    assert_equal 5, envelope.center.y
+    height_before = envelope.height
+    width_before = envelope.width
+    
+    envelope.re_center_to_xy!(7,6)
+    
+    assert_equal 7, envelope.center.x
+    assert_equal 6, envelope.center.y
+    assert_equal height_before, envelope.height 
+    assert_equal width_before, envelope.width 
+  end
+  
+  def test_should_recenter_to_coord
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    assert_equal 5, envelope.center.x
+    assert_equal 5, envelope.center.y
+    height_before = envelope.height
+    width_before = envelope.width
+    
+    envelope.re_center_to_coord!(Mapnik::Coord2d.new(7,6))
+    
+    assert_equal 7, envelope.center.x
+    assert_equal 6, envelope.center.y
+    assert_equal height_before, envelope.height 
+    assert_equal width_before, envelope.width 
+  end
+  
+  def test_should_know_if_it_contains_an_xy
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    assert !envelope.contains_xy?(11, 11)
+    assert envelope.contains_xy?(5, 5)
+  end
+  
+  def test_should_know_if_it_contains_a_coord
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    assert !envelope.contains_coord?(Mapnik::Coord2d.new(11, 11))
+    assert envelope.contains_coord?(Mapnik::Coord2d.new(5, 5))
+  end
+  
+  def test_should_know_if_it_contains_another_envelope
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    assert !envelope.contains_envelope?(Mapnik::Envelope.new(20,20,30,30))
+    assert !envelope.contains_envelope?(Mapnik::Envelope.new(9,9,12,12))
+    assert envelope.contains_envelope?(Mapnik::Envelope.new(5,5,6,6))
+  end
+  
+  def test_should_know_if_it_intersects_an_xy
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    assert !envelope.intersects_xy?(11, 11)
+    assert envelope.intersects_xy?(5, 5)
+  end
+  
+  def test_should_know_if_it_intersects_a_coord
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    assert !envelope.intersects_coord?(Mapnik::Coord2d.new(11, 11))
+    assert envelope.intersects_coord?(Mapnik::Coord2d.new(5, 5))
+  end
+  
+  def test_should_know_if_it_intersects_another_envelope
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    assert !envelope.intersects_envelope?(Mapnik::Envelope.new(20,20,30,30))
+    assert envelope.intersects_envelope?(Mapnik::Envelope.new(9,9,12,12))
+    assert envelope.intersects_envelope?(Mapnik::Envelope.new(5,5,6,6))
+  end
+  
+  def test_should_expand_to_include_an_xy
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    assert !envelope.contains_xy?(11, 11)
+    height_before = envelope.height
+    width_before = envelope.width
+    
+    envelope.expand_to_include_xy!(11, 11)
+    
+    assert envelope.contains_xy?(11, 11)
+    assert_equal height_before + 1, envelope.height 
+    assert_equal width_before + 1, envelope.width
+  end
+  
+  def test_should_expand_to_include_a_coord
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    coord = Mapnik::Coord2d.new(11, 11)
+    assert !envelope.contains_coord?(coord)
+    height_before = envelope.height
+    width_before = envelope.width
+    
+    envelope.expand_to_include_coord!(coord)
+    
+    assert envelope.contains_coord?(coord)
+    assert_equal height_before + 1, envelope.height 
+    assert_equal width_before + 1, envelope.width
+  end
+  
+  def test_should_expand_to_include_an_envelope
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    other_envelope = Mapnik::Envelope.new(11, 11, 12, 12)
+    assert !envelope.contains_envelope?(other_envelope)
+    height_before = envelope.height
+    width_before = envelope.width
+    
+    envelope.expand_to_include_envelope!(other_envelope)
+    
+    assert envelope.contains_envelope?(other_envelope)
+    assert_equal height_before + 2, envelope.height 
+    assert_equal width_before + 2, envelope.width
+  end
+  
+  def test_should_provide_an_intersection
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    other_envelope = Mapnik::Envelope.new(9,9,12,12)
+    assert envelope.intersects_envelope?(other_envelope)
+    
+    intersection = envelope.intersection(other_envelope)
+    
+    assert_not_equal(intersection, envelope)
+    assert_not_equal(other_envelope, intersection)
+    assert envelope.contains_envelope?(intersection)
+    assert other_envelope.contains_envelope?(intersection)
+  end
+  
+  def test_should_clip
+    envelope = Mapnik::Envelope.new(0,0,10,10)
+    width_before = envelope.width
+    other_envelope = Mapnik::Envelope.new(9,9,12,12)
+    assert envelope.intersects_envelope?(other_envelope)
+    
+    envelope.clip!(other_envelope)
+    
+    assert envelope.intersects_envelope?(other_envelope)
+    assert_not_equal(width_before, envelope.width)
+  end
+  
+  def test_validity
+    envelope = Mapnik::Envelope.new(0,0,-1,-1)
+    assert envelope.min_x <= envelope.max_x
+    assert envelope.min_y <= envelope.max_y
+    assert envelope.valid?
+  end
+  
+end

data/test/test_mapnik_expression.rb

@@ -0,0 +1,19 @@
+require "test_helper"
+
+class TestMapnikExpression < Test::Unit::TestCase
+  
+  def test_presence
+    assert Mapnik::Expression
+    assert Mapnik::PathExpression
+  end
+
+  def test_should_evaluate
+    expression = "([place]='town')"
+    assert_equal expression, Mapnik::Expression.parse(expression).to_s
+  end
+
+  def test_should_parse_path
+    assert Mapnik::PathExpression.parse("/my/path.png")
+  end
+
+end

data/test/test_mapnik_feature.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class TestMapnikFeature < Test::Unit::TestCase
+  
+  def test_presence
+    assert Mapnik::Feature
+  end
+  
+  def test_should_instantiate
+    feature_id = 12
+    assert feature = Mapnik::Feature.new(feature_id)
+    assert_equal feature_id, feature.id
+    assert_equal "feature (  id:#{feature_id})", feature.to_s.gsub("\n", '')
+  end
+  
+  def test_should_return_number_of_geometries
+    assert feature = Mapnik::Feature.new(1)
+    assert_equal 0, feature.number_of_geometries
+  end
+  
+  def test_should_return_its_envelope
+    assert feature = Mapnik::Feature.new(1)
+    assert feature.envelope.kind_of?(Mapnik::Envelope)
+  end
+  
+  def test_should_add_a_geometry
+    feature = Mapnik::Feature.new(1)
+    assert_equal(0, feature.number_of_geometries)
+    feature.add_geometry("POINT(30 10)")
+    assert_equal(1, feature.number_of_geometries)
+  end
+  
+end

data/test/test_mapnik_font_engine.rb

@@ -0,0 +1,13 @@
+require "test_helper"
+
+class TestMapnikFontEngine < Test::Unit::TestCase
+  
+  def test_presence
+    assert Mapnik::FontEngine
+  end
+  
+  def test_face_name
+    assert Mapnik::FontEngine.face_names.instance_of?(Array)
+  end
+  
+end

data/test/test_mapnik_geometry.rb

@@ -0,0 +1,72 @@
+require "test_helper"
+
+class TestMapnikGeometry < Test::Unit::TestCase
+  
+  def test_presence
+    assert Mapnik::GeometryType
+    assert Mapnik::Geometry2d
+    assert Mapnik::GeometryType::Point
+    assert Mapnik::GeometryType::LineString
+    assert Mapnik::GeometryType::Polygon
+    assert Mapnik::GeometryType::MultiPoint
+    assert Mapnik::GeometryType::MultiLineString
+  end
+  
+  def test_should_make_point_from_wkt
+    point = Mapnik::Geometry2d.from_wkt("POINT(30 10)")
+    assert_equal Mapnik::GeometryType::Point, point.type
+    assert_equal 30, point.envelope.min_x
+    assert_equal 30, point.envelope.max_x
+    assert_equal 10, point.envelope.max_y
+    assert_equal 10, point.envelope.min_y
+    assert_equal 0, point.area
+  end
+  
+  def test_should_make_linestring_from_wkt
+    linestring = Mapnik::Geometry2d.from_wkt("LINESTRING (29 11, 12 30, 41 40)")
+    assert_equal Mapnik::GeometryType::LineString, linestring.type
+    assert_equal 12, linestring.envelope.min_x
+    assert_equal 41, linestring.envelope.max_x
+    assert_equal 40, linestring.envelope.max_y
+    assert_equal 11, linestring.envelope.min_y
+    # assert_equal 0, linestring.area -> Not sure what the correct value is here  
+  end
+  
+  def test_should_make_polygon_from_wkt
+    polygon = Mapnik::Geometry2d.from_wkt("POLYGON ((30 10, 10 20, 20 40, 40 40, 30 10))")
+    assert_equal Mapnik::GeometryType::Polygon, polygon.type
+    assert_equal 10, polygon.envelope.min_x
+    assert_equal 40, polygon.envelope.max_x
+    assert_equal 40, polygon.envelope.max_y
+    assert_equal 10, polygon.envelope.min_y
+    # assert_equal 0, polygon.area
+  end
+  
+  def test_should_make_multipoint_from_wkt
+    multipoint = Mapnik::Geometry2d.from_wkt("MULTIPOINT (10 40, 40 30, 20 20, 30 10)")
+    assert_equal Mapnik::GeometryType::MultiPoint, multipoint.type
+    assert_equal 10, multipoint.envelope.min_x
+    assert_equal 40, multipoint.envelope.max_x
+    assert_equal 40, multipoint.envelope.max_y
+    assert_equal 10, multipoint.envelope.min_y
+  end
+  
+  def test_should_make_multilinestring_from_wkt
+    multi_line = Mapnik::Geometry2d.from_wkt("MULTILINESTRING ((10 10, 20 20, 10 40), (40 40, 30 30, 40 20, 30 10))")
+    assert_equal Mapnik::GeometryType::MultiLineString, multi_line.type
+    assert_equal 10, multi_line.envelope.min_x
+    assert_equal 40, multi_line.envelope.max_x
+    assert_equal 40, multi_line.envelope.max_y
+    assert_equal 10, multi_line.envelope.min_y
+  end
+  
+  def test_should_make_multipolygon_from_wkt
+    multi_polygon = Mapnik::Geometry2d.from_wkt("MULTIPOLYGON (((30 20, 10 40, 45 40, 30 20)), ((15 5, 40 10, 10 20, 5 10, 15 5)))")
+    assert_equal Mapnik::GeometryType::MultiPolygon, multi_polygon.type
+    assert_equal 5, multi_polygon.envelope.min_x
+    assert_equal 45, multi_polygon.envelope.max_x
+    assert_equal 40, multi_polygon.envelope.max_y
+    assert_equal 5, multi_polygon.envelope.min_y
+  end
+  
+end