gd2-ffij 0.0.4 → 0.0.5

data/lib/gd2/image.rb

@@ -114,7 +114,7 @@ module GD2
 
       type = data_type(magic) or
         raise UnrecognizedImageTypeError, 'Image data format is not recognized'
-      ptr = GD2FFI.send(create[type], *args)
+      ptr = ::GD2::GD2FFI.send(create[type], *args)
       raise LibraryError unless ptr
 
       ptr = FFIStruct::ImagePtr.new(ptr)
@@ -168,9 +168,9 @@ module GD2
       ptr = # TODO: implement xpm and xbm imports
       #if format == :xpm
         #raise ArgumentError, "Unexpected options #{options.inspect}" unless options.empty?
-        #GD2FFI.send(:gdImageCreateFromXpm, filename)
+        #::GD2::GD2FFI.send(:gdImageCreateFromXpm, filename)
       #elsif format == :xbm
-        #GD2FFI.send(:gdImageCreateFromXbm, filename)
+        #::GD2::GD2FFI.send(:gdImageCreateFromXbm, filename)
       if format == :gd2 && !options.empty?
         x, y, width, height =
           options.delete(:x) || 0, options.delete(:y) || 0,
@@ -182,7 +182,7 @@ module GD2
         raise ArgumentError, 'Missing required option :height' if height.nil?
         # TODO:
         ptr = File.open(filename, 'rb') do |file|
-          GD2FFI.send(:gdImageCreateFromGd2Part, file, x.to_i, y.to_i, width.to_i, height.to_i)
+          ::GD2::GD2FFI.send(:gdImageCreateFromGd2Part, file, x.to_i, y.to_i, width.to_i, height.to_i)
         end
       else
         raise ArgumentError, "Unexpected options #{options.inspect}" unless
@@ -204,7 +204,7 @@ module GD2
         file_ptr = FFI::MemoryPointer.new(file.size, 1, false)
         file_ptr.put_bytes(0, file)
 
-        GD2FFI.send(create_sym, file.size, file_ptr)
+        ::GD2::GD2FFI.send(create_sym, file.size, file_ptr)
       end
       raise LibraryError unless ptr
 
@@ -222,8 +222,8 @@ module GD2
     private_class_method :image_true_color?
 
     def self.create_image_ptr(sx, sy, alpha_blending = true)  #:nodoc:
-      ptr = FFIStruct::ImagePtr.new(GD2FFI.send(create_image_sym, sx.to_i, sy.to_i))
-      GD2FFI.send(:gdImageAlphaBlending, ptr, alpha_blending ? 1 : 0)
+      ptr = FFIStruct::ImagePtr.new(::GD2::GD2FFI.send(create_image_sym, sx.to_i, sy.to_i))
+      ::GD2::GD2FFI.send(:gdImageAlphaBlending, ptr, alpha_blending ? 1 : 0)
       ptr
     end
 
@@ -239,7 +239,7 @@ module GD2
       end
 
       @palette = self.class.palette_class.new(self) unless
-        @palette && @palette.image == self
+        defined?(@palette) && @palette.image == self
       self
     end
 
@@ -257,7 +257,7 @@ module GD2
     # identical, otherwise a bit field indicating the differences. See the
     # GD2::CMP_* constants for individual bit flags.
     def compare(other)
-      GD2FFI.send(:gdImageCompare, image_ptr, other.image_ptr)
+      ::GD2::GD2FFI.send(:gdImageCompare, image_ptr, other.image_ptr)
     end
 
     # Compare this image with another image. Returns *false* if the images are
@@ -297,13 +297,13 @@ module GD2
 
     # Return the pixel value at image location (+x+, +y+).
     def get_pixel(x, y)
-      GD2FFI.send(:gdImageGetPixel, @image_ptr, x.to_i, y.to_i)
+      ::GD2::GD2FFI.send(:gdImageGetPixel, @image_ptr, x.to_i, y.to_i)
     end
     alias pixel get_pixel
 
     # Set the pixel value at image location (+x+, +y+).
     def set_pixel(x, y, value)
-      GD2FFI.send(:gdImageSetPixel, @image_ptr, x.to_i, y.to_i, value.to_i)
+      ::GD2::GD2FFI.send(:gdImageSetPixel, @image_ptr, x.to_i, y.to_i, value.to_i)
       nil
     end
 
@@ -320,11 +320,10 @@ module GD2
     # Iterate over each row of pixels in the image, returning an array of
     # pixel values.
     def each
-      ptr = image_ptr
       (0...height).each do |y|
-        row = (0...width).inject(Array.new(width)) do |row, x|
-          row[x] = get_pixel(x, y)
-          row
+        row = (0...width).inject(Array.new(width)) do |r, x|
+          r[x] = get_pixel(x, y)
+          r
         end
         yield row
       end
@@ -349,7 +348,7 @@ module GD2
     # Set whether this image will be stored in interlaced form when output as
     # PNG or JPEG.
     def interlaced=(bool)
-      GD2FFI.send(:gdImageInterlace, image_ptr, bool ? 1 : 0)
+      ::GD2::GD2FFI.send(:gdImageInterlace, image_ptr, bool ? 1 : 0)
     end
 
     # Return *true* if colors will be alpha blended into the image when pixels
@@ -363,7 +362,7 @@ module GD2
     # pixels are modified. Alpha blending is not available for IndexedColor
     # images.
     def alpha_blending=(bool)
-      GD2FFI.send(:gdImageAlphaBlending, image_ptr, bool ? 1 : 0)
+      ::GD2::GD2FFI.send(:gdImageAlphaBlending, image_ptr, bool ? 1 : 0)
     end
 
     # Return *true* if this image will be stored with full alpha channel
@@ -375,7 +374,7 @@ module GD2
     # Set whether this image will be stored with full alpha channel information
     # when output as PNG.
     def save_alpha=(bool)
-      GD2FFI.send(:gdImageSaveAlpha, image_ptr, bool ? 1 : 0)
+      ::GD2::GD2FFI.send(:gdImageSaveAlpha, image_ptr, bool ? 1 : 0)
     end
 
     # Return the transparent color for this image, or *nil* if none has been
@@ -387,7 +386,7 @@ module GD2
 
     # Set or unset the transparent color for this image.
     def transparent=(color)
-      GD2FFI.send(:gdImageColorTransparent, image_ptr,
+      ::GD2::GD2FFI.send(:gdImageColorTransparent, image_ptr,
         color.nil? ? -1 : color2pixel(color))
     end
 
@@ -399,7 +398,7 @@ module GD2
       x2 = FFI::MemoryPointer.new(:pointer)
       y2 = FFI::MemoryPointer.new(:pointer)
 
-      GD2FFI.send(:gdImageGetClip, image_ptr, x1, y1, x2, y2)
+      ::GD2::GD2FFI.send(:gdImageGetClip, image_ptr, x1, y1, x2, y2)
       [ x1.read_int, y1.read_int, x2.read_int, y2.read_int ]
     end
 
@@ -410,18 +409,18 @@ module GD2
       clip = clipping
       begin
         p clipping
-        GD2FFI.send(:gdImageSetClip, image_ptr, x1.to_i, y1.to_i, x2.to_i, y2.to_i)
+        ::GD2::GD2FFI.send(:gdImageSetClip, image_ptr, x1.to_i, y1.to_i, x2.to_i, y2.to_i)
         p clipping
         yield self
         self
       ensure
-        GD2FFI.send(:gdImageSetClip, image_ptr, *clip)
+        ::GD2::GD2FFI.send(:gdImageSetClip, image_ptr, *clip)
       end
     end
 
     # Return *true* if the current clipping rectangle excludes the given point.
     def clips?(x, y)
-      GD2FFI.send(:gdImageBoundsSafe, image_ptr, x.to_i, y.to_i).zero?
+      ::GD2::GD2FFI.send(:gdImageBoundsSafe, image_ptr, x.to_i, y.to_i).zero?
     end
 
     # Provide a drawing environment for a block. See GD2::Canvas.
@@ -482,10 +481,10 @@ module GD2
 
       File.open(filename, 'wb') do |file|
         begin
-          img = GD2FFI.send(write_sym, image_ptr, *args)
+          img = ::GD2::GD2FFI.send(write_sym, image_ptr, *args)
           file.write(img.get_bytes(0, size.get_int(0)))
         ensure
-          GD2FFI.gdFree(img)
+          ::GD2::GD2FFI.gdFree(img)
         end
       end
     end
@@ -495,10 +494,10 @@ module GD2
     # implying both higher quality and larger sizes.
     def jpeg(quality = nil)
       size = FFI::MemoryPointer.new(:pointer)
-      ptr = GD2FFI.send(:gdImageJpegPtr, image_ptr, size, quality || -1)
+      ptr = ::GD2::GD2FFI.send(:gdImageJpegPtr, image_ptr, size, quality || -1)
       ptr.get_bytes(0, size.get_int(0))
     ensure
-      GD2FFI.send(:gdFree, ptr)
+      ::GD2::GD2FFI.send(:gdFree, ptr)
     end
 
     # Encode and return data for this image in PNG format. The +level+
@@ -506,10 +505,10 @@ module GD2
     # compression (0 = none, 1 = minimal but fast, 9 = best but slow).
     def png(level = nil)
       size = FFI::MemoryPointer.new(:pointer)
-      ptr = GD2FFI.send(:gdImagePngPtrEx, image_ptr, size, level.to_i || -1)
+      ptr = ::GD2::GD2FFI.send(:gdImagePngPtrEx, image_ptr, size, level.to_i || -1)
       ptr.get_bytes(0, size.get_int(0))
     ensure
-      GD2FFI.send(:gdFree, ptr)
+      ::GD2::GD2FFI.send(:gdFree, ptr)
     end
 
     # Encode and return data for this image in GIF format. Note that GIF only
@@ -518,10 +517,10 @@ module GD2
     # Image#to_indexed_color to control this conversion more precisely.
     def gif
       size = FFI::MemoryPointer.new(:pointer)
-      ptr = GD2FFI.send(:gdImageGifPtr, image_ptr, size)
+      ptr = ::GD2::GD2FFI.send(:gdImageGifPtr, image_ptr, size)
       ptr.get_bytes(0, size.get_int(0))
     ensure
-      GD2FFI.send(:gdFree, ptr)
+      ::GD2::GD2FFI.send(:gdFree, ptr)
     end
 
     # Encode and return data for this image in WBMP format. WBMP currently
@@ -530,20 +529,20 @@ module GD2
     # considered “background” (white).
     def wbmp(fgcolor)
       size = FFI::MemoryPointer.new(:pointer)
-      ptr = GD2FFI.send(:gdImageWBMPPtr, image_ptr, size, color2pixel(fgcolor))
+      ptr = ::GD2::GD2FFI.send(:gdImageWBMPPtr, image_ptr, size, color2pixel(fgcolor))
       ptr.get_bytes(0, size.get_int(0))
     ensure
-      GD2FFI.send(:gdFree, ptr)
+      ::GD2::GD2FFI.send(:gdFree, ptr)
     end
 
     # Encode and return data for this image in “.gd” format. This is an
     # internal format used by the gd library to quickly read and write images.
     def gd
       size = FFI::MemoryPointer.new(:pointer)
-      ptr = GD2FFI.send(:gdImageGdPtr, image_ptr, size)
+      ptr = ::GD2::GD2FFI.send(:gdImageGdPtr, image_ptr, size)
       ptr.get_bytes(0, size.get_int(0))
     ensure
-      GD2FFI.send(:gdFree, ptr)
+      ::GD2::GD2FFI.send(:gdFree, ptr)
     end
 
     # Encode and return data for this image in “.gd2” format. This is an
@@ -551,10 +550,10 @@ module GD2
     # The specified +fmt+ may be either GD2::FMT_RAW or GD2::FMT_COMPRESSED.
     def gd2(fmt = FMT_COMPRESSED, chunk_size = 0)
       size = FFI::MemoryPointer.new(:pointer)
-      ptr = GD2FFI.send(:gdImageGd2Ptr, image_ptr, chunk_size.to_i, fmt.to_i, size)
+      ptr = ::GD2::GD2FFI.send(:gdImageGd2Ptr, image_ptr, chunk_size.to_i, fmt.to_i, size)
       ptr.get_bytes(0, size.get_int(0))
     ensure
-      GD2FFI.send(:gdFree, ptr)
+      ::GD2::GD2FFI.send(:gdFree, ptr)
     end
 
     # Copy a portion of another image to this image. If +src_w+ and +src_h+ are
@@ -564,10 +563,10 @@ module GD2
         dst_w, dst_h, src_w = nil, src_h = nil)
       raise ArgumentError unless src_w.nil? == src_h.nil?
       if src_w
-        GD2FFI.send(:gdImageCopyResampled, image_ptr, other.image_ptr,
+        ::GD2::GD2FFI.send(:gdImageCopyResampled, image_ptr, other.image_ptr,
           dst_x.to_i, dst_y.to_i, src_x.to_i, src_y.to_i, dst_w.to_i, dst_h.to_i, src_w.to_i, src_h.to_i)
       else
-        GD2FFI.send(:gdImageCopy, image_ptr, other.image_ptr,
+        ::GD2::GD2FFI.send(:gdImageCopy, image_ptr, other.image_ptr,
           dst_x.to_i, dst_y.to_i, src_x.to_i, src_y.to_i, dst_w.to_i, dst_h.to_i)
       end
       self
@@ -578,7 +577,7 @@ module GD2
     # +dst_y+ arguments indicate the _center_ of the desired destination, and
     # may be floating point.
     def copy_from_rotated(other, dst_x, dst_y, src_x, src_y, w, h, angle)
-      GD2FFI.send(:gdImageCopyRotated, image_ptr, other.image_ptr,
+      ::GD2::GD2FFI.send(:gdImageCopyRotated, image_ptr, other.image_ptr,
         dst_x.to_f, dst_y.to_f, src_x.to_i, src_y.to_i, w.to_i, h.to_i, angle.to_degrees.round.to_i)
       self
     end
@@ -588,7 +587,7 @@ module GD2
     # Image#copy_from; a percentage of 0.0 is a no-op. Note that alpha
     # channel information from the source image is ignored.
     def merge_from(other, dst_x, dst_y, src_x, src_y, w, h, pct)
-      GD2FFI.send(:gdImageCopyMerge, image_ptr, other.image_ptr,
+      ::GD2::GD2FFI.send(:gdImageCopyMerge, image_ptr, other.image_ptr,
         dst_x.to_i, dst_y.to_i, src_x.to_i, src_y.to_i, w.to_i, h.to_i, pct.to_percent.round.to_i)
       self
     end
@@ -597,7 +596,7 @@ module GD2
     # coordinates. Note that some of the edges of the image may be lost.
     def rotate!(angle, axis_x = width / 2.0, axis_y = height / 2.0)
       ptr = self.class.create_image_ptr(width, height, alpha_blending?)
-      GD2FFI.send(:gdImageCopyRotated, ptr, image_ptr,
+      ::GD2::GD2FFI.send(:gdImageCopyRotated, ptr, image_ptr,
         axis_x.to_f, axis_y.to_f, 0, 0, width.to_i, height.to_i, angle.to_degrees.round.to_i)
       init_with_image(ptr)
     end
@@ -611,7 +610,7 @@ module GD2
     # (0, 0).
     def crop!(x, y, w, h)
       ptr = self.class.create_image_ptr(w, h, alpha_blending?)
-      GD2FFI.send(:gdImageCopy, ptr, image_ptr, 0, 0, x.to_i, y.to_i, w.to_i, h.to_i)
+      ::GD2::GD2FFI.send(:gdImageCopy, ptr, image_ptr, 0, 0, x.to_i, y.to_i, w.to_i, h.to_i)
       init_with_image(ptr)
     end
 
@@ -625,7 +624,7 @@ module GD2
     def uncrop!(x1, y1 = x1, x2 = x1, y2 = y1)
       ptr = self.class.create_image_ptr(x1 + width + x2, y1 + height + y2,
         alpha_blending?)
-      GD2FFI.send(:gdImageCopy, ptr, image_ptr, x1.to_i, y1.to_i, 0, 0, width.to_i, height.to_i)
+      ::GD2::GD2FFI.send(:gdImageCopy, ptr, image_ptr, x1.to_i, y1.to_i, 0, 0, width.to_i, height.to_i)
       init_with_image(ptr)
     end
 
@@ -639,7 +638,7 @@ module GD2
     # shrunk as necessary without resampling.
     def resize!(w, h, resample = true)
       ptr = self.class.create_image_ptr(w, h, false)
-      GD2FFI.send(resample ? :gdImageCopyResampled : :gdImageCopyResized,
+      ::GD2::GD2FFI.send(resample ? :gdImageCopyResampled : :gdImageCopyResized,
         ptr, image_ptr, 0, 0, 0, 0, w.to_i, h.to_i, width.to_i, height.to_i)
       alpha_blending = alpha_blending?
       init_with_image(ptr)
@@ -658,7 +657,7 @@ module GD2
     # Note that the original image must be square.
     def polar_transform!(radius)
       raise 'Image must be square' unless width == height
-      ptr = GD2FFI.send(:gdImageSquareToCircle, image_ptr, radius.to_i)
+      ptr = ::GD2::GD2FFI.send(:gdImageSquareToCircle, image_ptr, radius.to_i)
       raise LibraryError unless ptr
       init_with_image(ptr)
     end
@@ -684,7 +683,7 @@ module GD2
     # +colors+ indicates the maximum number of palette colors to use, and
     # +dither+ controls whether dithering is used.
     def to_indexed_color(colors = MAX_COLORS, dither = true)
-      ptr = GD2FFI.send(:gdImageCreatePaletteFromTrueColor,
+      ptr = ::GD2::GD2FFI.send(:gdImageCreatePaletteFromTrueColor,
         to_true_color.image_ptr, dither ? 1 : 0, colors.to_i)
       raise LibraryError unless ptr
 
@@ -766,7 +765,7 @@ module GD2
     # grey scale before the merge.
     def merge_from(other, dst_x, dst_y, src_x, src_y, w, h, pct, gray = false)
       return super(other, dst_x, dst_y, src_x, src_y, w, h, pct) unless gray
-      GD2FFI.send(:gdImageCopyMergeGray, image_ptr, other.image_ptr,
+      ::GD2::GD2FFI.send(:gdImageCopyMergeGray, image_ptr, other.image_ptr,
         dst_x.to_i, dst_y.to_i, src_x.to_i, src_y.to_i, w.to_i, h.to_i, pct.to_percent.round.to_i)
       self
     end
@@ -788,7 +787,7 @@ module GD2
     end
 
     def sharpen(pct)  #:nodoc:
-      GD2FFI.send(:gdImageSharpen, image_ptr, pct.to_percent.round.to_i)
+      ::GD2::GD2FFI.send(:gdImageSharpen, image_ptr, pct.to_percent.round.to_i)
       self
     end
   end

data/lib/gd2/palette.rb

@@ -103,7 +103,7 @@ module GD2
     # a color from the palette that is closest to it.
     def resolve(color)
       raise TypeError unless color.kind_of? Color
-      c = GD2FFI.send(:gdImageColorResolveAlpha, @image.image_ptr,
+      c = ::GD2::GD2FFI.send(:gdImageColorResolveAlpha, @image.image_ptr,
         color.red.to_i, color.green.to_i, color.blue.to_i, color.alpha.to_i)
       c == -1 ? nil : get_color(c)
     end
@@ -112,7 +112,7 @@ module GD2
     # if the color is not presently in the palette.
     def exact(color)
       raise TypeError unless color.kind_of? Color
-      c = GD2FFI.send(:gdImageColorExactAlpha, @image.image_ptr,
+      c = ::GD2::GD2FFI.send(:gdImageColorExactAlpha, @image.image_ptr,
         color.red.to_i, color.green.to_i, color.blue.to_i, color.alpha.to_i)
       c == -1 ? nil : get_color(c)
     end
@@ -128,7 +128,7 @@ module GD2
     # according to Euclidian distance.
     def closest(color)
       raise TypeError unless color.kind_of? Color
-      c = GD2FFI.send(:gdImageColorClosestAlpha, @image.image_ptr,
+      c = ::GD2::GD2FFI.send(:gdImageColorClosestAlpha, @image.image_ptr,
         color.red.to_i, color.green.to_i, color.blue.to_i, color.alpha.to_i)
       c == -1 ? nil : get_color(c)
     end
@@ -137,7 +137,7 @@ module GD2
     # according to hue, whiteness, and blackness.
     def closest_hwb(color)
       raise TypeError unless color.kind_of? Color
-      c = GD2FFI.send(:gdImageColorClosestHWB, @image.image_ptr,
+      c = ::GD2::GD2FFI.send(:gdImageColorClosestHWB, @image.image_ptr,
         color.red.to_i, color.green.to_i, color.blue.to_i)
       c == -1 ? nil : get_color(c)
     end
@@ -147,7 +147,7 @@ module GD2
     # raises an error for Image::IndexedColor palettes if the palette is full.
     def allocate(color)
       raise TypeError unless color.kind_of? Color
-      c = GD2FFI.send(:gdImageColorAllocateAlpha, @image.image_ptr,
+      c = ::GD2::GD2FFI.send(:gdImageColorAllocateAlpha, @image.image_ptr,
         color.red.to_i, color.green.to_i, color.blue.to_i, color.alpha.to_i)
       c == -1 ? raise(Palette::PaletteFullError, 'Palette is full') :
         get_color(c)
@@ -164,7 +164,7 @@ module GD2
     def deallocate(color)
       color = exact(color) unless color.index
       return nil if color.nil? || color.index.nil?
-      GD2FFI.send(:gdImageColorDeallocate, @image.image_ptr, color.index.to_i)
+      ::GD2::GD2FFI.send(:gdImageColorDeallocate, @image.image_ptr, color.index.to_i)
       nil
     end
 

data/lib/gd2/version.rb

@@ -0,0 +1,5 @@
+
+module GD2
+  VERSION = "0.0.5"
+end
+

data/test/canvas_tests.rb

@@ -1,186 +1,181 @@
-require 'test/unit'
-require 'tmpdir'
-
-require 'rubygems'
-require 'gd2-ffij'
 
 require './test/test_helper'
 
 class CanvasTest < Test::Unit::TestCase
-	include TestHelper
-
-	def test_line
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
-			pen.line(64, 64, 192, 192)
-		end
-		assert(image == load_image('test_canvas_line.gd2'))
-	end
-
-	def test_rectangle
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
-			pen.rectangle(64, 64, 192, 192)
-		end
-		assert(image == load_image('test_canvas_rectangle.gd2'))
-	end
-
-	def test_filled_rectangle
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
-			pen.rectangle(64, 64, 192, 192, true)
-		end
-		assert(image == load_image('test_canvas_filled_rectangle.gd2'))
-	end
-
-	def test_polygon
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
-			pen.polygon([
-				[ 64, 64 ],
-				[ 192, 192 ],
-				[ 64, 128 ]
-			])
-		end
-		assert(image == load_image('test_canvas_polygon.gd2'))
-	end
-
-	def test_filled_polygon
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
-			pen.polygon([
-				[ 64, 64 ],
-				[ 192, 192 ],
-				[ 64, 128 ]
-			], true)
-		end
-		assert(image == load_image('test_canvas_filled_polygon.gd2'))
-	end
-
-	def test_move_to_and_line_to
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
-			pen.move_to(64, 64)
-			pen.line_to(128, 128)
-		end
-		assert(image == load_image('test_canvas_move_to_and_line_to.gd2'))
-	end
-
-	def test_fill
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-			pen.rectangle(64, 64, 192, 192)
-			pen.move_to(65, 65)
-			pen.fill
-		end
-		assert(image == load_image('test_fill.gd2'))
-	end
-
-	def test_arc
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-			pen.arc(128, 128, 128, 128, 0..256)
-		end
-		assert(image == load_image('test_arc.gd2'))
-	end
-
-	def test_text
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-			pen.font = GD2::Font::TrueType[PATH_TO_FONT, 32]
-			pen.move_to(0, 128)
-			pen.text("HELLO")
-			pen.move_to(256, 128)
-			pen.text("WORLD", Math::PI)
-		end
-		assert(image == load_image('test_text.gd2'))
-	end
-
-	def test_text_circle
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-			pen.font = GD2::Font::TrueType[PATH_TO_FONT, 32]
-			pen.move_to(128, 128)
-			pen.text_circle('HELLO', 'WORLD', 100, 20, 1)
-		end
-		assert(image == load_image('test_text_circle.gd2'))
-	end
-
-	def test_wedge
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-			pen.wedge(128, 128, 256, 256, 0..180)
-		end
-		assert(image == load_image('test_wedge.gd2'))
-	end
-
-	def test_filled_wedge
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-			pen.wedge(128, 128, 256, 256, 0..180, true)
-		end
-		assert(image == load_image('test_filled_wedge.gd2'))
-	end
-
-	def test_ellipse
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-			pen.ellipse(128, 128, 64, 32)
-		end
-		assert(image == load_image('test_ellipse.gd2'))
-	end
-
-	def test_filled_ellipse
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-			pen.ellipse(128, 128, 64, 32, true)
-		end
-		assert(image == load_image('test_filled_ellipse.gd2'))
-	end
-
-	def test_circle
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-			pen.circle(128, 128, 128)
-		end
-		assert(image == load_image('test_circle.gd2'))
-	end
-
-	def test_filled_circle
-		image = new_image
-		image.draw do |pen|
-			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-			pen.circle(128, 128, 128, true)
-		end
-		assert(image == load_image('test_filled_circle.gd2'))
-	end
-
-	def test_fill_to
-		image = new_image
-		image.draw do |pen|
-			blue = image.palette.resolve(GD2::Color[32, 64, 128])
-			red	= image.palette.resolve(GD2::Color[255, 0, 0])
-			pen.color = blue
-			pen.arc(128, 128, 256, 64, 0..(Math::PI))
-			pen.color = red
-			pen.move(128, 128)
-			pen.fill_to(blue)
-		end
-		assert(image == load_image('test_fill_to.gd2'))
-	end
+  include TestHelper
+
+  def test_line
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+      pen.line(64, 64, 192, 192)
+    end
+    assert(image == load_image('test_canvas_line.gd2'))
+  end
+
+  def test_rectangle
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+      pen.rectangle(64, 64, 192, 192)
+    end
+    assert(image == load_image('test_canvas_rectangle.gd2'))
+  end
+
+  def test_filled_rectangle
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+      pen.rectangle(64, 64, 192, 192, true)
+    end
+    assert(image == load_image('test_canvas_filled_rectangle.gd2'))
+  end
+
+  def test_polygon
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+      pen.polygon([
+        [ 64, 64 ],
+        [ 192, 192 ],
+        [ 64, 128 ]
+      ])
+    end
+    assert(image == load_image('test_canvas_polygon.gd2'))
+  end
+
+  def test_filled_polygon
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+      pen.polygon([
+        [ 64, 64 ],
+        [ 192, 192 ],
+        [ 64, 128 ]
+      ], true)
+    end
+    assert(image == load_image('test_canvas_filled_polygon.gd2'))
+  end
+
+  def test_move_to_and_line_to
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+      pen.move_to(64, 64)
+      pen.line_to(128, 128)
+    end
+    assert(image == load_image('test_canvas_move_to_and_line_to.gd2'))
+  end
+
+  def test_fill
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.rectangle(64, 64, 192, 192)
+      pen.move_to(65, 65)
+      pen.fill
+    end
+    assert(image == load_image('test_fill.gd2'))
+  end
+
+  def test_arc
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.arc(128, 128, 128, 128, 0..256)
+    end
+    assert(image == load_image('test_arc.gd2'))
+  end
+
+  def test_text
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.font = GD2::Font::TrueType[PATH_TO_FONT, 32]
+      pen.move_to(0, 128)
+      pen.text("HELLO")
+      pen.move_to(256, 128)
+      pen.text("WORLD", Math::PI)
+    end
+    assert(image == load_image('test_text.gd2'))
+  end
+
+  def test_text_circle
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.font = GD2::Font::TrueType[PATH_TO_FONT, 32]
+      pen.move_to(128, 128)
+      pen.text_circle('HELLO', 'WORLD', 100, 20, 1)
+    end
+    assert(image == load_image('test_text_circle.gd2'))
+  end
+
+  def test_wedge
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.wedge(128, 128, 256, 256, 0..180)
+    end
+    assert(image == load_image('test_wedge.gd2'))
+  end
+
+  def test_filled_wedge
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.wedge(128, 128, 256, 256, 0..180, true)
+    end
+    assert(image == load_image('test_filled_wedge.gd2'))
+  end
+
+  def test_ellipse
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.ellipse(128, 128, 64, 32)
+    end
+    assert(image == load_image('test_ellipse.gd2'))
+  end
+
+  def test_filled_ellipse
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.ellipse(128, 128, 64, 32, true)
+    end
+    assert(image == load_image('test_filled_ellipse.gd2'))
+  end
+
+  def test_circle
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.circle(128, 128, 128)
+    end
+    assert(image == load_image('test_circle.gd2'))
+  end
+
+  def test_filled_circle
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.circle(128, 128, 128, true)
+    end
+    assert(image == load_image('test_filled_circle.gd2'))
+  end
+
+  def test_fill_to
+    image = new_image
+    image.draw do |pen|
+      blue = image.palette.resolve(GD2::Color[32, 64, 128])
+      red  = image.palette.resolve(GD2::Color[255, 0, 0])
+      pen.color = blue
+      pen.arc(128, 128, 256, 64, 0..(Math::PI))
+      pen.color = red
+      pen.move(128, 128)
+      pen.fill_to(blue)
+    end
+    assert(image == load_image('test_fill_to.gd2'))
+  end
 end