pnm 0.4.1 → 0.6.0

data/test/backports.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module PNM
+  module Backports  # :nodoc:
+    module Minitest  # :nodoc:
+
+      # Provides workaround for missing value wrappers in minitest < 5.6.0.
+      def _(value = nil, &block)
+        block || value
+      end
+    end
+  end
+end
+
+
+if Gem.loaded_specs["minitest"].version < Gem::Version.new("5.6.0")
+  warn "Using workaround for missing value wrappers in minitest < 5.6.0."
+  include PNM::Backports::Minitest
+end

data/test/test_converter.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 # test_converter.rb: Unit tests for the PNM library.
 #
-# Copyright (C) 2013-2015 Marcus Stollsteimer
+# Copyright (C) 2013-2020 Marcus Stollsteimer
+
+require "minitest/autorun"
+require "pnm/converter"
 
-require 'minitest/autorun'
-require 'pnm/converter'
+require_relative "backports"
 
 
 describe PNM::Converter do
@@ -11,196 +15,197 @@ describe PNM::Converter do
   before do
     @converter = PNM::Converter
 
-    @pbm6  = {
-               :width  => 6,
-               :height => 2,
-               :array  => [[0,1,0,0,1,1], [0,0,0,1,1,1]],
-               :ascii  => "0 1 0 0 1 1\n0 0 0 1 1 1\n",
-               :binary => ['4C1C'].pack('H*')
-             }
+    @pbm6 = {
+      width:  6,
+      height: 2,
+      array:  [[0, 1, 0, 0, 1, 1], [0, 0, 0, 1, 1, 1]],
+      ascii:  "0 1 0 0 1 1\n0 0 0 1 1 1\n",
+      binary: ["4C1C"].pack("H*")
+    }
 
     @pbm14 = {
-               :width  => 14,
-               :height => 2,
-               :array  => [[0,0,1,1,1,0,0,0,1,1,0,0,1,0], [0,1,0,1,1,0,1,1,1,0,1,1,1,1]],
-               :ascii  => "0 0 1 1 1 0 0 0 1 1 0 0 1 0\n0 1 0 1 1 0 1 1 1 0 1 1 1 1\n",
-               :binary => ['38C85BBC'].pack('H*')
-             }
+      width:  14,
+      height: 2,
+      array:  [[0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0],
+               [0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1]],
+      ascii:  "0 0 1 1 1 0 0 0 1 1 0 0 1 0\n0 1 0 1 1 0 1 1 1 0 1 1 1 1\n",
+      binary: ["38C85BBC"].pack("H*")
+    }
 
     @pbm = @pbm14
 
-    @pgm =   {
-               :width  => 4,
-               :height => 3,
-               :array  => [[0, 85, 170, 255], [85, 170, 255, 0], [170, 255, 0, 85]],
-               :ascii  => "0 85 170 255\n85 170 255 0\n170 255 0 85\n",
-               :binary => ['0055AAFF55AAFF00AAFF0055'].pack('H*')
-             }
-
-    @ppm =   {
-               :width  => 3,
-               :height => 2,
-               :array  => [[[0,128,255], [128,255,0], [255,0,128]],
-                           [[255,128,0], [128,0,255], [0,255,128]]],
-               :ascii  => "0 128 255 128 255 0 255 0 128\n255 128 0 128 0 255 0 255 128\n",
-               :binary => ['0080FF80FF00FF0080FF80008000FF00FF80'].pack('H*')
-             }
-  end
-
-  it 'can convert from ASCII encoded PBM data' do
+    @pgm = {
+      width:  4,
+      height: 3,
+      array:  [[0, 85, 170, 255], [85, 170, 255, 0], [170, 255, 0, 85]],
+      ascii:  "0 85 170 255\n85 170 255 0\n170 255 0 85\n",
+      binary: ["0055AAFF55AAFF00AAFF0055"].pack("H*")
+    }
+
+    @ppm = {
+      width:  3,
+      height: 2,
+      array:  [[[0, 128, 255], [128, 255, 0], [255, 0, 128]],
+               [[255, 128, 0], [128, 0, 255], [0, 255, 128]]],
+      ascii:  "0 128 255 128 255 0 255 0 128\n255 128 0 128 0 255 0 255 128\n",
+      binary: ["0080FF80FF00FF0080FF80008000FF00FF80"].pack("H*")
+    }
+  end
+
+  it "can convert from ASCII encoded PBM data" do
     width    = @pbm[:width]
     height   = @pbm[:height]
     data     = @pbm[:ascii]
     expected = @pbm[:array]
 
-    @converter.ascii2array(:pbm, width, height, data).must_equal expected
+    _(@converter.ascii2array(:pbm, width, height, data)).must_equal expected
   end
 
-  it 'can convert from ASCII encoded PGM data' do
+  it "can convert from ASCII encoded PGM data" do
     width    = @pgm[:width]
     height   = @pgm[:height]
     data     = @pgm[:ascii]
     expected = @pgm[:array]
 
-    @converter.ascii2array(:pgm, width, height, data).must_equal expected
+    _(@converter.ascii2array(:pgm, width, height, data)).must_equal expected
   end
 
-  it 'can convert from ASCII encoded PPM data' do
+  it "can convert from ASCII encoded PPM data" do
     width    = @ppm[:width]
     height   = @ppm[:height]
     data     = @ppm[:ascii]
     expected = @ppm[:array]
 
-    @converter.ascii2array(:ppm, width, height, data).must_equal expected
+    _(@converter.ascii2array(:ppm, width, height, data)).must_equal expected
   end
 
-  it 'accepts ASCII encoded PBM data with omitted whitespace' do
+  it "accepts ASCII encoded PBM data with omitted whitespace" do
     width    = 4
     height   = 3
     data     = "  010100\n000110"
     expected = [[0, 1, 0, 1], [0, 0, 0, 0], [0, 1, 1, 0]]
 
-    @converter.ascii2array(:pbm, width, height, data).must_equal expected
+    _(@converter.ascii2array(:pbm, width, height, data)).must_equal expected
   end
 
-  it 'accepts ASCII encoded PGM data with arbitrary whitespace' do
+  it "accepts ASCII encoded PGM data with arbitrary whitespace" do
     width    = 4
     height   = 3
     data     = "  \n 10 90\t170\r250\n90 \t170   250 \t\r\n\t 10\n\n\n170\n250\n10\n90\n"
     expected = [[10, 90, 170, 250], [90, 170, 250, 10], [170, 250, 10, 90]]
 
-    @converter.ascii2array(:pgm, width, height, data).must_equal expected
+    _(@converter.ascii2array(:pgm, width, height, data)).must_equal expected
   end
 
-  it 'can convert from binary encoded PBM data (width 6)' do
+  it "can convert from binary encoded PBM data (width 6)" do
     width    = @pbm6[:width]
     height   = @pbm6[:height]
     data     = @pbm6[:binary]
     expected = @pbm6[:array]
 
-    @converter.binary2array(:pbm, width, height, data).must_equal expected
+    _(@converter.binary2array(:pbm, width, height, data)).must_equal expected
   end
 
-  it 'can convert from binary encoded PBM data (width 14)' do
+  it "can convert from binary encoded PBM data (width 14)" do
     width    = @pbm14[:width]
     height   = @pbm14[:height]
     data     = @pbm14[:binary]
     expected = @pbm14[:array]
 
-    @converter.binary2array(:pbm, width, height, data).must_equal expected
+    _(@converter.binary2array(:pbm, width, height, data)).must_equal expected
   end
 
-  it 'can convert from binary encoded PGM data' do
+  it "can convert from binary encoded PGM data" do
     width    = @pgm[:width]
     height   = @pgm[:height]
     data     = @pgm[:binary]
     expected = @pgm[:array]
 
-    @converter.binary2array(:pgm, width, height, data).must_equal expected
+    _(@converter.binary2array(:pgm, width, height, data)).must_equal expected
   end
 
-  it 'can convert from binary encoded PPM data' do
+  it "can convert from binary encoded PPM data" do
     width    = @ppm[:width]
     height   = @ppm[:height]
     data     = @ppm[:binary]
     expected = @ppm[:array]
 
-    @converter.binary2array(:ppm, width, height, data).must_equal expected
+    _(@converter.binary2array(:ppm, width, height, data)).must_equal expected
   end
 
-  it 'accepts an additional whitespace character for binary encoded data' do
+  it "accepts an additional whitespace character for binary encoded data" do
     width    = @pbm14[:width]
     height   = @pbm14[:height]
     data     = @pbm14[:binary] + "\t"
     expected = @pbm14[:array]
 
-    @converter.binary2array(:pbm, width, height, data).must_equal expected
+    _(@converter.binary2array(:pbm, width, height, data)).must_equal expected
   end
 
-  it 'can convert to ASCII encoded PBM data' do
+  it "can convert to ASCII encoded PBM data" do
     data     = @pbm[:array]
     expected = @pbm[:ascii]
 
-    @converter.array2ascii(data).must_equal expected
+    _(@converter.array2ascii(data)).must_equal expected
   end
 
-  it 'can convert to ASCII encoded PGM data' do
+  it "can convert to ASCII encoded PGM data" do
     data     = @pgm[:array]
     expected = @pgm[:ascii]
 
-    @converter.array2ascii(data).must_equal expected
+    _(@converter.array2ascii(data)).must_equal expected
   end
 
-  it 'can convert to ASCII encoded PPM data' do
+  it "can convert to ASCII encoded PPM data" do
     data     = @ppm[:array]
     expected = @ppm[:ascii]
 
-    @converter.array2ascii(data).must_equal expected
+    _(@converter.array2ascii(data)).must_equal expected
   end
 
-  it 'can convert to binary encoded PBM data (width 6)' do
+  it "can convert to binary encoded PBM data (width 6)" do
     data     = @pbm6[:array]
     expected = @pbm6[:binary]
 
-    @converter.array2binary(:pbm, data).must_equal expected
+    _(@converter.array2binary(:pbm, data)).must_equal expected
   end
 
-  it 'can convert to binary encoded PBM data (width 14)' do
+  it "can convert to binary encoded PBM data (width 14)" do
     data     = @pbm14[:array]
     expected = @pbm14[:binary]
 
-    @converter.array2binary(:pbm, data).must_equal expected
+    _(@converter.array2binary(:pbm, data)).must_equal expected
   end
 
-  it 'can convert to binary encoded PGM data' do
+  it "can convert to binary encoded PGM data" do
     data     = @pgm[:array]
     expected = @pgm[:binary]
 
-    @converter.array2binary(:pgm, data).must_equal expected
+    _(@converter.array2binary(:pgm, data)).must_equal expected
   end
 
-  it 'can convert to binary encoded PPM data' do
+  it "can convert to binary encoded PPM data" do
     data     = @ppm[:array]
     expected = @ppm[:binary]
 
-    @converter.array2binary(:ppm, data).must_equal expected
+    _(@converter.array2binary(:ppm, data)).must_equal expected
   end
 
-  it 'can calculate correct byte widths for a PBM image' do
-    @converter.byte_width(:pbm,  0).must_equal 0
-    @converter.byte_width(:pbm,  1).must_equal 1
-    @converter.byte_width(:pbm,  7).must_equal 1
-    @converter.byte_width(:pbm,  8).must_equal 1
-    @converter.byte_width(:pbm,  9).must_equal 2
-    @converter.byte_width(:pbm, 64).must_equal 8
-    @converter.byte_width(:pbm, 65).must_equal 9
+  it "can calculate correct byte widths for a PBM image" do
+    _(@converter.byte_width(:pbm,  0)).must_equal 0
+    _(@converter.byte_width(:pbm,  1)).must_equal 1
+    _(@converter.byte_width(:pbm,  7)).must_equal 1
+    _(@converter.byte_width(:pbm,  8)).must_equal 1
+    _(@converter.byte_width(:pbm,  9)).must_equal 2
+    _(@converter.byte_width(:pbm, 64)).must_equal 8
+    _(@converter.byte_width(:pbm, 65)).must_equal 9
   end
 
-  it 'can calculate correct byte widths for a PGM image' do
-    @converter.byte_width(:pgm, 13).must_equal 13
+  it "can calculate correct byte widths for a PGM image" do
+    _(@converter.byte_width(:pgm, 13)).must_equal 13
   end
 
-  it 'can calculate correct byte widths for a PPM image' do
-    @converter.byte_width(:ppm, 13).must_equal 39
+  it "can calculate correct byte widths for a PPM image" do
+    _(@converter.byte_width(:ppm, 13)).must_equal 39
   end
 end

data/test/test_exceptions.rb

@@ -1,234 +1,238 @@
+# frozen_string_literal: true
+
 # test_exceptions.rb: Unit tests for the PNM library.
 #
-# Copyright (C) 2013-2015 Marcus Stollsteimer
+# Copyright (C) 2013-2020 Marcus Stollsteimer
+
+require "minitest/autorun"
+require "stringio"
+require "pnm"
 
-require 'minitest/autorun'
-require 'stringio'
-require 'pnm'
+require_relative "backports"
 
 
-describe 'PNM.create' do
+describe "PNM.create" do
 
-  it 'raises an exception for invalid data type (String)' do
-    data = '0'
-    lambda { PNM.create(data) }.must_raise PNM::ArgumentError
+  it "raises an exception for invalid data type (String)" do
+    data = "0"
+    _ { PNM.create(data) }.must_raise PNM::ArgumentError
   end
 
-  it 'raises an exception for invalid type' do
+  it "raises an exception for invalid type" do
     data = [[0, 0], [0, 0]]
-    lambda { PNM.create(data, :type => :abc) }.must_raise PNM::ArgumentError
+    _ { PNM.create(data, type: :abc) }.must_raise PNM::ArgumentError
   end
 
-  it 'raises an exception for invalid maxgray (String)' do
+  it "raises an exception for invalid maxgray (String)" do
     data = [[0, 0], [0, 0]]
-    lambda { PNM.create(data, :maxgray => '255') }.must_raise PNM::ArgumentError
+    _ { PNM.create(data, maxgray: "255") }.must_raise PNM::ArgumentError
   end
 
-  it 'raises an exception for invalid maxgray (> 255)' do
+  it "raises an exception for invalid maxgray (> 255)" do
     data = [[0, 0], [0, 0]]
-    lambda { PNM.create(data, :maxgray => 256) }.must_raise PNM::ArgumentError
+    _ { PNM.create(data, maxgray: 256) }.must_raise PNM::ArgumentError
   end
 
-  it 'raises an exception for invalid maxgray (0)' do
+  it "raises an exception for invalid maxgray (0)" do
     data = [[0, 0], [0, 0]]
-    lambda { PNM.create(data, :maxgray => 0) }.must_raise PNM::ArgumentError
+    _ { PNM.create(data, maxgray: 0) }.must_raise PNM::ArgumentError
   end
 
-  it 'raises an exception for invalid comment (Fixnum)' do
+  it "raises an exception for invalid comment (Integer)" do
     data = [[0, 0], [0, 0]]
-    lambda { PNM.create(data, :comment => 1) }.must_raise PNM::ArgumentError
+    _ { PNM.create(data, comment: 1) }.must_raise PNM::ArgumentError
   end
 
-  it 'raises an exception for image type and data mismatch (PBM)' do
-    data = [[[0,0,0], [0,0,0]], [[0,0,0], [0,0,0]]]
-    lambda { PNM.create(data, :type => :pbm) }.must_raise PNM::DataError
+  it "raises an exception for image type and data mismatch (PBM)" do
+    data = [[[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]]
+    _ { PNM.create(data, type: :pbm) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for image type and data mismatch (PGM)' do
-    data = [[[0,0,0], [0,0,0]], [[0,0,0], [0,0,0]]]
-    lambda { PNM.create(data, :type => :pgm) }.must_raise PNM::DataError
+  it "raises an exception for image type and data mismatch (PGM)" do
+    data = [[[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]]
+    _ { PNM.create(data, type: :pgm) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for non-integer pixel value (String)' do
-    data = [[0, 0], ['X', 0]]
-    lambda { PNM.create(data) }.must_raise PNM::DataError
+  it "raises an exception for non-integer pixel value (String)" do
+    data = [[0, 0], ["X", 0]]
+    _ { PNM.create(data) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for non-integer pixel value (Float)' do
+  it "raises an exception for non-integer pixel value (Float)" do
     data = [[0, 0], [0.5, 0]]
-    lambda { PNM.create(data) }.must_raise PNM::DataError
+    _ { PNM.create(data) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for rows of different size' do
+  it "raises an exception for rows of different size" do
     data = [[0, 0], [0, 0, 0]]
-    lambda { PNM.create(data) }.must_raise PNM::DataError
+    _ { PNM.create(data) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for invalid array dimensions (#1)' do
+  it "raises an exception for invalid array dimensions (#1)" do
     data = [0, 0, 0]
-    lambda { PNM.create(data) }.must_raise PNM::DataError
+    _ { PNM.create(data) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for invalid array dimensions (#2)' do
+  it "raises an exception for invalid array dimensions (#2)" do
     data = [[0, 0], 0, 0]
-    lambda { PNM.create(data) }.must_raise PNM::DataError
+    _ { PNM.create(data) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for invalid array dimensions (#3)' do
+  it "raises an exception for invalid array dimensions (#3)" do
     data = [[0, 0], [0, [0, 0]]]
-    lambda { PNM.create(data) }.must_raise PNM::DataError
+    _ { PNM.create(data) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for invalid array dimensions (#4)' do
-    data = [[[0,0], [0,0]], [[0,0], [0,0]]]
-    lambda { PNM.create(data) }.must_raise PNM::DataError
+  it "raises an exception for invalid array dimensions (#4)" do
+    data = [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
+    _ { PNM.create(data) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for invalid array dimensions (#5)' do
-    data = [[[0,0,0], [0,0,0]], [0 ,0]]
-    lambda { PNM.create(data) }.must_raise PNM::DataError
+  it "raises an exception for invalid array dimensions (#5)" do
+    data = [[[0, 0, 0], [0, 0, 0]], [0, 0]]
+    _ { PNM.create(data) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for invalid array dimensions (#6)' do
-    data = [[[0,0,0], 0], [0 ,0]]
-    lambda { PNM.create(data) }.must_raise PNM::DataError
+  it "raises an exception for invalid array dimensions (#6)" do
+    data = [[[0, 0, 0], 0], [0, 0]]
+    _ { PNM.create(data) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for an empty array' do
+  it "raises an exception for an empty array" do
     data = [[]]
-    lambda { PNM.create(data) }.must_raise PNM::DataError
+    _ { PNM.create(data) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for invalid PBM data (> 1)' do
+  it "raises an exception for invalid PBM data (> 1)" do
     data = [[0, 0], [2, 0]]
-    lambda { PNM.create(data, :type => :pbm) }.must_raise PNM::DataError
+    _ { PNM.create(data, type: :pbm) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for invalid PBM data (< 0)' do
+  it "raises an exception for invalid PBM data (< 0)" do
     data = [[0, 0], [-1, 0]]
-    lambda { PNM.create(data, :type => :pbm) }.must_raise PNM::DataError
+    _ { PNM.create(data, type: :pbm) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for invalid PGM data (> 255)' do
+  it "raises an exception for invalid PGM data (> 255)" do
     data = [[0, 0], [1, 500]]
-    lambda { PNM.create(data, :type => :pgm) }.must_raise PNM::DataError
+    _ { PNM.create(data, type: :pgm) }.must_raise PNM::DataError
   end
 
-  it 'raises an exception for invalid PGM data (> maxgray)' do
+  it "raises an exception for invalid PGM data (> maxgray)" do
     data = [[0, 0], [1, 200]]
-    lambda { PNM.create(data, :maxgray => 100) }.must_raise PNM::DataError
+    _ { PNM.create(data, maxgray: 100) }.must_raise PNM::DataError
   end
 end
 
 
-describe 'PNM.read' do
+describe "PNM.read" do
 
-  it 'raises an exception for integer argument' do
-    lambda { PNM.read(123) }.must_raise PNM::ArgumentError
+  it "raises an exception for integer argument" do
+    _ { PNM.read(123) }.must_raise PNM::ArgumentError
   end
 
-  it 'raises an exception for unknown magic number' do
-    file = StringIO.new('P0 1 1 0')
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+  it "raises an exception for unknown magic number" do
+    file = StringIO.new("P0 1 1 0")
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for an empty file' do
-    file = StringIO.new('')
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+  it "raises an exception for an empty file" do
+    file = StringIO.new("")
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for missing tokens (#1)' do
-    file = StringIO.new('P1')
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+  it "raises an exception for missing tokens (#1)" do
+    file = StringIO.new("P1")
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for missing tokens (#2)' do
-    file = StringIO.new('P1 1')
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+  it "raises an exception for missing tokens (#2)" do
+    file = StringIO.new("P1 1")
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for missing tokens (#3)' do
-    file = StringIO.new('P1 1 ')
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+  it "raises an exception for missing tokens (#3)" do
+    file = StringIO.new("P1 1 ")
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for missing tokens (#4)' do
-    file = StringIO.new('P1 1 1')
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+  it "raises an exception for missing tokens (#4)" do
+    file = StringIO.new("P1 1 1")
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for missing tokens (#5)' do
+  it "raises an exception for missing tokens (#5)" do
     file = StringIO.new("P1 1  # Test\n 1")
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for missing tokens (#6)' do
+  it "raises an exception for missing tokens (#6)" do
     file = StringIO.new("P2 1 1 255")
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for token of wrong type (#1)' do
-    file = StringIO.new('P1 ? 1 0')
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+  it "raises an exception for token of wrong type (#1)" do
+    file = StringIO.new("P1 ? 1 0")
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for token of wrong type (#2)' do
-    file = StringIO.new('P1 1 X 0')
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+  it "raises an exception for token of wrong type (#2)" do
+    file = StringIO.new("P1 1 X 0")
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for token of wrong type (#3)' do
-    file = StringIO.new('P2 1 1 foo 0')
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+  it "raises an exception for token of wrong type (#3)" do
+    file = StringIO.new("P2 1 1 foo 0")
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for zero width' do
-    file = StringIO.new('P2 0 1 255 0')
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+  it "raises an exception for zero width" do
+    file = StringIO.new("P2 0 1 255 0")
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for zero height' do
-    file = StringIO.new('P2 1 0 255 0')
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+  it "raises an exception for zero height" do
+    file = StringIO.new("P2 1 0 255 0")
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for invalid maxgray (> 255)' do
-    file = StringIO.new('P2 1 1 256 0')
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+  it "raises an exception for invalid maxgray (> 255)" do
+    file = StringIO.new("P2 1 1 256 0")
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for invalid maxgray (0)' do
-    file = StringIO.new('P2 1 1 0 0')
-    lambda { PNM.read(file) }.must_raise PNM::ParserError
+  it "raises an exception for invalid maxgray (0)" do
+    file = StringIO.new("P2 1 1 0 0")
+    _ { PNM.read(file) }.must_raise PNM::ParserError
   end
 
-  it 'raises an exception for image dimension mismatch (#1)' do
-    file = StringIO.new('P1 2 3 0 0 0 0 0')
-    lambda { PNM.read(file) }.must_raise PNM::DataSizeError
+  it "raises an exception for image dimension mismatch (#1)" do
+    file = StringIO.new("P1 2 3 0 0 0 0 0")
+    _ { PNM.read(file) }.must_raise PNM::DataSizeError
   end
 
-  it 'raises an exception for image dimension mismatch (#2)' do
-    file = StringIO.new('P1 2 3 0 0 0 0 0 0 0')
-    lambda { PNM.read(file) }.must_raise PNM::DataSizeError
+  it "raises an exception for image dimension mismatch (#2)" do
+    file = StringIO.new("P1 2 3 0 0 0 0 0 0 0")
+    _ { PNM.read(file) }.must_raise PNM::DataSizeError
   end
 
-  it 'raises an exception for image dimension mismatch (#3)' do
-    file = StringIO.new('P3 2 3 255 0 0 0 0 0 0')
-    lambda { PNM.read(file) }.must_raise PNM::DataSizeError
+  it "raises an exception for image dimension mismatch (#3)" do
+    file = StringIO.new("P3 2 3 255 0 0 0 0 0 0")
+    _ { PNM.read(file) }.must_raise PNM::DataSizeError
   end
 
-  it 'raises an exception for image dimension mismatch (#4)' do
-    file = StringIO.new('P5 2 3 255 AAAAAAA')
-    lambda { PNM.read(file) }.must_raise PNM::DataSizeError
+  it "raises an exception for image dimension mismatch (#4)" do
+    file = StringIO.new("P5 2 3 255 AAAAAAA")
+    _ { PNM.read(file) }.must_raise PNM::DataSizeError
   end
 
-  it 'raises an exception for image dimension mismatch (#5)' do
-    file = StringIO.new('P5 2 3 255 AAAAAAA')
-    lambda { PNM.read(file) }.must_raise PNM::DataSizeError
+  it "raises an exception for image dimension mismatch (#5)" do
+    file = StringIO.new("P5 2 3 255 AAAAAAA")
+    _ { PNM.read(file) }.must_raise PNM::DataSizeError
   end
 
-  it 'raises an exception for non-numeric image data' do
-    file = StringIO.new('P1 2 3 0 X 0 0 0 0')
-    lambda { PNM.read(file) }.must_raise PNM::DataError
+  it "raises an exception for non-numeric image data" do
+    file = StringIO.new("P1 2 3 0 X 0 0 0 0")
+    _ { PNM.read(file) }.must_raise PNM::DataError
   end
 end