ruby_mapnik 0.1

data/test/test_mapnik_raster_symbolizer.rb

@@ -0,0 +1,40 @@
+require "test_helper"
+
+class TestMapnikRasterSymbolizer < Test::Unit::TestCase
+  
+  def setup
+    @sym = Mapnik::RasterSymbolizer.new
+  end
+  
+  def test_presence
+    assert Mapnik::RasterSymbolizer
+  end
+  
+  def test_should_get_and_set_mode
+    possible_values = ["normal", "grain_merge", "grain_merge2", "multiply",
+     "multiply2", "divide", "divide2", "screen", "hard_light"]
+    possible_values.each do |value|
+      @sym.mode = value
+      assert_equal value, @sym.mode
+    end
+  end
+  
+  def test_should_get_and_set_scaling
+    possible_values = [ "fast","bilinear","bilinear8"]
+    possible_values.each do |value|
+      @sym.scaling = value
+      assert_equal value, @sym.scaling
+    end
+  end
+  
+  def test_should_get_and_set_opacity
+    @sym.opacity = 0.5
+    assert_equal 0.5, @sym.opacity
+  end
+  
+  def test_should_get_and_set_filter_factor
+    @sym.filter_factor = 0.5
+    assert_equal 0.5, @sym.filter_factor
+  end
+  
+end

data/test/test_mapnik_rule.rb

@@ -0,0 +1,63 @@
+require "test_helper"
+
+class TestMapnikRule < Test::Unit::TestCase
+  
+  def test_presence
+    assert Mapnik::Rule
+  end
+  
+  def test_should_instantiate
+    assert Mapnik::Rule.new
+  end
+  
+  def test_should_get_and_set_name
+    rule = Mapnik::Rule.new
+    assert_equal("", rule.name)
+    
+    new_name = "New name"
+    rule.name = new_name
+    assert_equal new_name, rule.name
+  end
+  
+  def test_should_get_and_set_title
+    rule = Mapnik::Rule.new
+    assert_equal("", rule.title)
+    
+    new_title = "New title"
+    rule.title = new_title
+    assert_equal new_title, rule.title
+  end
+  
+  def test_should_get_and_set_abstract
+    rule = Mapnik::Rule.new
+    assert_equal("", rule.abstract)
+    
+    new_abstract = "New abstract"
+    rule.abstract = new_abstract
+    assert_equal new_abstract, rule.abstract
+  end
+  
+  def test_should_get_and_set_filter
+    rule = Mapnik::Rule.new
+    expression_string = "([place]='town')"
+    expression = Mapnik::Expression.parse(expression_string)
+    rule.filter = expression
+    assert_equal expression_string, rule.filter.to_s
+  end
+  
+  def test_should_append_and_remove_symbols
+    rule = Mapnik::Rule.new
+    assert_equal 0, rule.symbols.count
+    rule.symbols << Mapnik::PolygonSymbolizer.new
+    assert_equal 1, rule.symbols.count
+    rule.symbols << Mapnik::LineSymbolizer.new
+    assert_equal 2, rule.symbols.count
+    
+    obj = rule.symbols.delete_at(0)
+    assert obj
+    assert_equal 1, rule.symbols.count
+    assert rule.symbols.pop
+    assert_equal 0, rule.symbols.count
+  end
+  
+end

data/test/test_mapnik_shield_symbolizer.rb

@@ -0,0 +1,193 @@
+require "test_helper"
+
+class TestMapnikShieldSymbolizer < Test::Unit::TestCase
+  
+  def setup
+    expression = Mapnik::Expression.parse("[place]")
+    face_name = "DejaVu Sans Book"
+    fill = Mapnik::Color.new("#fff")
+    file = Mapnik::PathExpression.parse("myfile.png")
+    @sym = Mapnik::ShieldSymbolizer.new(expression, face_name, 12, fill, file)
+  end
+    
+  def test_should_instantiate
+    assert @sym
+  end
+
+  def test_should_get_and_set_anchor
+    assert @sym.anchor
+    new_vals = [1,2]
+    @sym.anchor = new_vals
+    assert_equal new_vals, @sym.anchor
+  end
+  
+  def test_should_get_and_set_allow_overlap
+    @sym.allow_overlap = true
+    assert @sym.allow_overlap?
+    @sym.allow_overlap = false
+    assert !@sym.allow_overlap?
+  end
+
+  def test_should_get_and_set_displacement
+    assert @sym.displacement
+    new_vals = [1,2]
+    @sym.displacement = new_vals
+    assert_equal new_vals, @sym.displacement
+  end
+  
+  def test_should_get_and_set_shield_displacement
+    assert @sym.shield_displacement
+    new_vals = [1,2]
+    @sym.shield_displacement = new_vals
+    assert_equal new_vals, @sym.shield_displacement
+  end
+  
+  def test_should_get_and_set_avoid_edges
+    @sym.avoid_edges = true
+    assert @sym.avoid_edges?
+    @sym.avoid_edges = false
+    assert !@sym.avoid_edges?
+  end
+  
+  def test_should_get_and_set_character_spacing
+    assert_equal 0, @sym.character_spacing
+    @sym.character_spacing = 1
+    assert_equal 1, @sym.character_spacing
+  end
+  
+  def test_should_get_and_set_face_name
+    assert_equal "DejaVu Sans Book", @sym.face_name
+    @sym.face_name = "DejaVu Sans"
+    assert_equal "DejaVu Sans", @sym.face_name
+  end
+  
+  def test_should_get_and_set_fill
+    assert @sym.fill.instance_of?(Mapnik::Color)
+    white = Mapnik::Color.new("#fff")
+    @sym.fill = white
+    assert_equal white, @sym.fill
+  end
+  
+  # TODO: Need fontset
+  # def test_should_get_and_set_fontset
+  #   raise @sym.fontset.inspect
+  # end
+  
+  def test_should_get_and_set_force_odd_labels
+    @sym.force_odd_labels = true
+    assert @sym.force_odd_labels?
+    @sym.force_odd_labels = false
+    assert !@sym.force_odd_labels?  
+  end
+  
+  def test_should_get_and_set_halo_fill
+    assert @sym.halo_fill.instance_of?(Mapnik::Color)
+    white = Mapnik::Color.new("#fff")
+    @sym.halo_fill = white
+    assert_equal white, @sym.halo_fill
+  end
+  
+  def test_should_get_and_set_halo_radius
+    assert_equal 0, @sym.halo_radius
+    @sym.halo_radius = 1
+    assert_equal 1, @sym.halo_radius
+  end
+  
+  def test_should_get_and_set_horizontal_alignment
+    @sym.horizontal_alignment = Mapnik::HORIZONTAL_ALIGNMENT::LEFT
+    assert_equal Mapnik::HORIZONTAL_ALIGNMENT::LEFT, @sym.horizontal_alignment
+    
+    @sym.horizontal_alignment = Mapnik::HORIZONTAL_ALIGNMENT::MIDDLE
+    assert_equal Mapnik::HORIZONTAL_ALIGNMENT::MIDDLE, @sym.horizontal_alignment
+    
+    @sym.horizontal_alignment = Mapnik::HORIZONTAL_ALIGNMENT::RIGHT
+    assert_equal Mapnik::HORIZONTAL_ALIGNMENT::RIGHT, @sym.horizontal_alignment
+  end
+  
+  def test_should_get_and_set_label_position_tolerance
+    assert_equal 0, @sym.label_position_tolerance
+    @sym.label_position_tolerance = 1
+    assert_equal 1, @sym.label_position_tolerance
+  end
+  
+  def test_should_get_and_set_label_spacing
+    assert_equal 0, @sym.label_spacing
+    @sym.label_spacing = 1
+    assert_equal 1, @sym.label_spacing
+  end
+  
+  def test_should_get_and_set_line_spacing
+    assert_equal 0, @sym.line_spacing
+    @sym.line_spacing = 1
+    assert_equal 1, @sym.line_spacing
+  end
+  
+  # TODO: failure here!
+  def test_should_get_and_set_max_char_angle_delta
+    @sym.max_char_angle_delta = 0.5
+    assert_equal 0.5, @sym.max_char_angle_delta
+    @sym.max_char_angle_delta = 0.7
+    assert_equal 0.7, @sym.max_char_angle_delta
+  end
+  
+  def test_should_get_and_set_minimum_distance
+    assert_equal 0, @sym.minimum_distance
+    @sym.minimum_distance = 1
+    assert_equal 1, @sym.minimum_distance
+  end
+  
+  def test_should_get_and_set_minimum_padding
+    assert_equal 0, @sym.minimum_padding
+    @sym.minimum_padding = 1
+    assert_equal 1, @sym.minimum_padding
+  end
+  
+  def test_should_get_and_set_name
+    assert @sym.name.instance_of?(Mapnik::Expression)
+    new_expression_string = "([place]='towns')"
+    assert_not_equal new_expression_string, @sym.name.to_s
+    new_expression = Mapnik::Expression.parse(new_expression_string)
+    @sym.name = new_expression
+    assert_equal new_expression_string, @sym.name.to_s
+  end
+  
+  def test_should_get_and_set_opactiy
+    assert_equal 1, @sym.opacity
+    @sym.opacity = 0
+    assert_equal 0, @sym.opacity
+  end
+  
+  def test_should_get_and_set_text_ratio
+    assert_equal 0, @sym.ratio
+    @sym.ratio = 3
+    assert_equal 3, @sym.ratio
+  end
+  
+  def test_should_get_and_set_text_size
+    assert_equal 12, @sym.size
+    @sym.size = 0
+    assert_equal 0, @sym.size
+  end
+  
+  def test_should_get_and_set_wrap_width
+    assert_equal 0, @sym.wrap_width
+    @sym.wrap_width = 30
+    assert_equal 30, @sym.wrap_width
+  end
+  
+  def test_should_get_and_set_wrap_character
+    @sym.wrap_character = '|'
+    assert_equal '|', @sym.wrap_character
+    @sym.wrap_character = '%'
+    assert_equal '%', @sym.wrap_character
+  end
+  
+  
+  
+  def test_should_get_and_set_wrap_before
+    assert !@sym.wrap_before
+    @sym.wrap_before = true
+    assert @sym.wrap_before
+  end
+  
+end

data/test/test_mapnik_stroke.rb

@@ -0,0 +1,94 @@
+require "test_helper"
+
+class TestMapnikStroke < Test::Unit::TestCase
+  
+  def setup
+    @color = Mapnik::Color.new("#ccc")
+    @stroke = Mapnik::Stroke.new(@color, 1.0)
+  end
+  
+  def test_should_instantiate
+    assert @stroke
+  end
+  
+  def test_should_get_and_set_color
+    assert @stroke.color == @color
+    new_color = Mapnik::Color.new("#fff")
+    @stroke.color = new_color
+    assert @stroke.color == new_color
+  end
+  
+  def test_should_get_and_set_opacity
+    opacity_before = @stroke.opacity
+    assert_equal 1, opacity_before
+    
+    new_opacity = 0.5
+    @stroke.opacity = new_opacity
+    assert_equal new_opacity, @stroke.opacity
+  end
+  
+  def test_should_get_and_set_gamma
+
+    gamma_before = @stroke.gamma
+    assert_equal 1, gamma_before
+    
+    new_gamma = 0.5
+    @stroke.gamma = new_gamma
+    assert_equal new_gamma, @stroke.gamma
+  end
+  
+  def test_should_get_and_set_width
+    width_before = @stroke.width
+    assert_equal 1, width_before
+    
+    new_width = 0.5
+    @stroke.width = new_width
+    assert_equal new_width, @stroke.width
+  end
+  
+  def test_should_have_line_caps
+    assert Mapnik::LineCap
+    assert Mapnik::LineCap::BUTT_CAP
+    assert Mapnik::LineCap::SQUARE_CAP
+    assert Mapnik::LineCap::ROUND_CAP
+  end
+  
+  def test_should_have_line_joins
+    assert Mapnik::LineJoin
+    assert Mapnik::LineJoin::MITER_JOIN
+    assert Mapnik::LineJoin::MITER_REVERT_JOIN
+    assert Mapnik::LineJoin::ROUND_JOIN
+    assert Mapnik::LineJoin::BEVEL_JOIN
+  end
+  
+  def test_should_get_and_set_line_cap
+    Mapnik::LineCap.constants.each do |const_name|
+      const = Mapnik::LineCap.const_get(const_name)
+      @stroke.line_cap = const
+      assert_equal const, @stroke.line_cap
+    end
+  end
+  
+  def test_should_get_and_set_line_join
+    Mapnik::LineJoin.constants.each do |const_name|
+      const = Mapnik::LineJoin.const_get(const_name)
+      @stroke.line_join = const
+      assert_equal const, @stroke.line_join
+    end
+  end
+  
+  def test_should_have_dashes
+    assert_equal 0, @stroke.dashes.length
+    dash_hash = {:gap => 1, :length => 1.2}
+    @stroke.dashes << dash_hash
+    assert_equal dash_hash, @stroke.dashes.first
+    assert_equal 1, @stroke.dashes.length
+  end
+  
+  def test_should_have_dash_offset
+    assert_equal 0, @stroke.dash_offset
+    @stroke.dash_offset = 1.4
+    assert_equal 1.4, @stroke.dash_offset 
+  end
+  
+end

data/test/test_mapnik_style.rb

@@ -0,0 +1,28 @@
+require "test_helper"
+
+class TestMapnikStyle < Test::Unit::TestCase
+  
+  def test_presence
+    assert Mapnik::Style
+  end
+  
+  def test_should_have_rules
+    style = Mapnik::Style.new
+    assert style.rules.empty?
+    rule = Mapnik::Rule.new
+    style.rules << rule
+    assert !style.rules.empty?
+  end
+  
+  def test_should_have_filter_types
+    assert Mapnik::FilterMode::ALL
+    assert Mapnik::FilterMode::FIRST
+  end
+  
+  def test_should_get_and_set_filter
+    style = Mapnik::Style.new
+    style.filter_mode = Mapnik::FilterMode::ALL
+    assert_equal Mapnik::FilterMode::ALL, style.filter_mode
+  end
+  
+end

data/test/test_mapnik_symbolizer.rb

@@ -0,0 +1,9 @@
+require "test_helper"
+
+class TestMapnikSymbolizer < Test::Unit::TestCase
+  
+  def test_presence
+    assert Mapnik::Symbolizer
+  end
+  
+end

data/test/test_mapnik_text_symbolizer.rb

@@ -0,0 +1,232 @@
+require "test_helper"
+
+class TestMapnikTextSymbolizer < Test::Unit::TestCase
+  
+  def setup
+    expression = Mapnik::Expression.parse("([place]='town')")
+    @symbolizer = Mapnik::TextSymbolizer.new(expression, "DejaVu Sans Book", 10, Mapnik::Color.new("#fff"))
+  end
+  
+  def test_should_instantiate
+    assert @symbolizer
+  end
+  
+  def test_enums_should_exist
+    assert Mapnik::LABEL_PLACEMENT::LINE_PLACEMENT
+    assert Mapnik::LABEL_PLACEMENT::POINT_PLACEMENT
+    assert Mapnik::LABEL_PLACEMENT::VERTEX_PLACEMENT
+    assert Mapnik::LABEL_PLACEMENT::INTERIOR_PLACEMENT
+
+    assert Mapnik::VERTICAL_ALIGNMENT::TOP
+    assert Mapnik::VERTICAL_ALIGNMENT::MIDDLE
+    assert Mapnik::VERTICAL_ALIGNMENT::BOTTOM
+    assert Mapnik::VERTICAL_ALIGNMENT::AUTO
+
+    assert Mapnik::HORIZONTAL_ALIGNMENT::LEFT
+    assert Mapnik::HORIZONTAL_ALIGNMENT::MIDDLE
+    assert Mapnik::HORIZONTAL_ALIGNMENT::RIGHT
+
+    assert Mapnik::JUSTIFY_ALIGNMENT::LEFT
+    assert Mapnik::JUSTIFY_ALIGNMENT::MIDDLE
+    assert Mapnik::JUSTIFY_ALIGNMENT::RIGHT
+
+    assert Mapnik::TEXT_TRANSFORM::NONE
+    assert Mapnik::TEXT_TRANSFORM::UPPERCASE
+    assert Mapnik::TEXT_TRANSFORM::LOWERCASE
+    assert Mapnik::TEXT_TRANSFORM::CAPITALIZE
+  end
+  
+  def test_should_get_and_set_anchor
+    assert @symbolizer.anchor
+    new_vals = [1,2]
+    @symbolizer.anchor = new_vals
+    assert_equal new_vals, @symbolizer.anchor
+  end
+  
+  def test_should_get_and_set_allow_overlap
+    @symbolizer.allow_overlap = true
+    assert @symbolizer.allow_overlap?
+    @symbolizer.allow_overlap = false
+    assert !@symbolizer.allow_overlap?
+  end
+
+  def test_should_get_and_set_displacement
+    assert @symbolizer.displacement
+    new_vals = [1,2]
+    @symbolizer.displacement = new_vals
+    assert_equal new_vals, @symbolizer.displacement
+  end
+  
+  def test_should_get_and_set_avoid_edges
+    @symbolizer.avoid_edges = true
+    assert @symbolizer.avoid_edges?
+    @symbolizer.avoid_edges = false
+    assert !@symbolizer.avoid_edges?
+  end
+  
+  def test_should_get_and_set_character_spacing
+    assert_equal 0, @symbolizer.character_spacing
+    @symbolizer.character_spacing = 1
+    assert_equal 1, @symbolizer.character_spacing
+  end
+
+  def test_should_get_and_set_face_name
+    assert_equal "DejaVu Sans Book", @symbolizer.face_name
+    @symbolizer.face_name = "DejaVu Sans"
+    assert_equal "DejaVu Sans", @symbolizer.face_name
+  end
+  
+  def test_should_get_and_set_fill
+    assert @symbolizer.fill.instance_of?(Mapnik::Color)
+    white = Mapnik::Color.new("#fff")
+    @symbolizer.fill = white
+    assert_equal white, @symbolizer.fill
+  end
+  
+  # TODO: Need fontset
+  # def test_should_get_and_set_fontset
+  #   raise @symbolizer.fontset.inspect
+  # end
+  
+  def test_should_get_and_set_force_odd_labels
+    @symbolizer.force_odd_labels = true
+    assert @symbolizer.force_odd_labels?
+    @symbolizer.force_odd_labels = false
+    assert !@symbolizer.force_odd_labels?  
+  end
+  
+  def test_should_get_and_set_halo_fill
+    assert @symbolizer.halo_fill.instance_of?(Mapnik::Color)
+    white = Mapnik::Color.new("#fff")
+    @symbolizer.halo_fill = white
+    assert_equal white, @symbolizer.halo_fill
+  end
+  
+  def test_should_get_and_set_halo_radius
+    assert_equal 0, @symbolizer.halo_radius
+    @symbolizer.halo_radius = 1
+    assert_equal 1, @symbolizer.halo_radius
+  end
+  
+  def test_should_get_and_set_horizontal_alignment
+    @symbolizer.horizontal_alignment = Mapnik::HORIZONTAL_ALIGNMENT::LEFT
+    assert_equal Mapnik::HORIZONTAL_ALIGNMENT::LEFT, @symbolizer.horizontal_alignment
+    
+    @symbolizer.horizontal_alignment = Mapnik::HORIZONTAL_ALIGNMENT::MIDDLE
+    assert_equal Mapnik::HORIZONTAL_ALIGNMENT::MIDDLE, @symbolizer.horizontal_alignment
+    
+    @symbolizer.horizontal_alignment = Mapnik::HORIZONTAL_ALIGNMENT::RIGHT
+    assert_equal Mapnik::HORIZONTAL_ALIGNMENT::RIGHT, @symbolizer.horizontal_alignment
+  end
+  
+  def test_should_get_and_set_justify_alignment
+    check_constant_setting(Mapnik::JUSTIFY_ALIGNMENT, :justify_alignment)
+  end
+  
+  def test_should_get_and_set_label_placement
+    check_constant_setting(Mapnik::LABEL_PLACEMENT, :label_placement)
+  end
+  
+  def test_should_get_and_set_label_position_tolerance
+    assert_equal 0, @symbolizer.label_position_tolerance
+    @symbolizer.label_position_tolerance = 1
+    assert_equal 1, @symbolizer.label_position_tolerance
+  end
+  
+  def test_should_get_and_set_label_spacing
+    assert_equal 0, @symbolizer.label_spacing
+    @symbolizer.label_spacing = 1
+    assert_equal 1, @symbolizer.label_spacing
+  end
+  
+  def test_should_get_and_set_line_spacing
+    assert_equal 0, @symbolizer.line_spacing
+    @symbolizer.line_spacing = 1
+    assert_equal 1, @symbolizer.line_spacing
+  end
+  
+  # TODO: failure here!
+  def test_should_get_and_set_max_char_angle_delta
+    @symbolizer.max_char_angle_delta = 0.5
+    assert_equal 0.5, @symbolizer.max_char_angle_delta
+    @symbolizer.max_char_angle_delta = 0.7
+    assert_equal 0.7, @symbolizer.max_char_angle_delta
+  end
+  
+  def test_should_get_and_set_minimum_distance
+    assert_equal 0, @symbolizer.minimum_distance
+    @symbolizer.minimum_distance = 1
+    assert_equal 1, @symbolizer.minimum_distance
+  end
+  
+  def test_should_get_and_set_minimum_padding
+    assert_equal 0, @symbolizer.minimum_padding
+    @symbolizer.minimum_padding = 1
+    assert_equal 1, @symbolizer.minimum_padding
+  end
+  
+  def test_should_get_and_set_name
+    assert @symbolizer.name.instance_of?(Mapnik::Expression)
+    new_expression_string = "([place]='towns')"
+    assert_not_equal new_expression_string, @symbolizer.name.to_s
+    new_expression = Mapnik::Expression.parse(new_expression_string)
+    @symbolizer.name = new_expression
+    assert_equal new_expression_string, @symbolizer.name.to_s
+  end
+  
+  def test_should_get_and_set_opactiy
+    assert_equal 1, @symbolizer.opacity
+    @symbolizer.opacity = 0
+    assert_equal 0, @symbolizer.opacity
+  end
+  
+  def test_should_get_and_set_text_transform
+    check_constant_setting(Mapnik::TEXT_TRANSFORM, :text_transform)
+  end
+  
+  def test_should_get_and_set_text_ratio
+    assert_equal 0, @symbolizer.ratio
+    @symbolizer.ratio = 3
+    assert_equal 3, @symbolizer.ratio
+  end
+  
+  def test_should_get_and_set_text_size
+    assert_equal 10, @symbolizer.size
+    @symbolizer.size = 0
+    assert_equal 0, @symbolizer.size
+  end
+  
+  def test_should_get_and_set_vertical_alignment
+    check_constant_setting(Mapnik::VERTICAL_ALIGNMENT, :vertical_alignment)
+  end
+  
+  def test_should_get_and_set_wrap_width
+    assert_equal 0, @symbolizer.wrap_width
+    @symbolizer.wrap_width = 30
+    assert_equal 30, @symbolizer.wrap_width
+  end
+  
+  def test_should_get_and_set_wrap_character
+    @symbolizer.wrap_character = '|'
+    assert_equal '|', @symbolizer.wrap_character
+    @symbolizer.wrap_character = '%'
+    assert_equal '%', @symbolizer.wrap_character
+  end
+  
+  def test_should_get_and_set_wrap_before
+    assert !@symbolizer.wrap_before
+    @symbolizer.wrap_before = true
+    assert @symbolizer.wrap_before
+  end
+  
+private  
+  
+  def check_constant_setting(enum, property)
+    enum.constants.each do |const_name|
+      const = enum.const_get(const_name)
+      @symbolizer.send(property.to_s + '=', const)
+      assert_equal const, @symbolizer.send(property)
+    end
+  end
+  
+end

data/test/test_polygon_pattern_symbolizer.rb

@@ -0,0 +1,34 @@
+require "test_helper"
+
+class TestPolygonPatternSymbolizer < Test::Unit::TestCase
+  
+  def setup
+    @filename = "/my/file.png"
+    path_expression = Mapnik::PathExpression.parse("/my/file.png")
+    @sym = Mapnik::PolygonPatternSymbolizer.new(path_expression)
+  end
+  
+  def test_presence
+    assert Mapnik::PolygonPatternSymbolizer
+    assert Mapnik::PatternAlignment::LOCAL
+    assert Mapnik::PatternAlignment::GLOBAL
+  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
+  
+  def test_should_get_and_set_pattern_alignment
+    assert_equal Mapnik::PatternAlignment::LOCAL, @sym.alignment
+    @sym.alignment = Mapnik::PatternAlignment::GLOBAL
+    assert_equal Mapnik::PatternAlignment::GLOBAL, @sym.alignment
+  end
+  
+end