barby 0.6.8 → 0.7.0

data/test/ean13_test.rb

@@ -29,7 +29,9 @@ class EAN13Test < Barby::TestCase
     end
 
     it "should raise an exception when data is invalid" do
-      lambda{ EAN13.new('123') }.must_raise(ArgumentError)
+      assert_raises ArgumentError do
+        EAN13.new('123')
+      end
     end
 
   end
@@ -42,40 +44,41 @@ class EAN13Test < Barby::TestCase
     end
 
     it "should have the same data as was passed to it" do
-      @code.data.must_equal @data
+      assert_equal @data, @code.data
     end
 
     it "should have the expected characters" do
-      @code.characters.must_equal @data.split(//)
+      assert_equal @data.split(//), @code.characters
     end
 
     it "should have the expected numbers" do
-      @code.numbers.must_equal @data.split(//).map{|s| s.to_i }
+      assert_equal @data.split(//).map{|s| s.to_i }, @code.numbers
     end
 
     it "should have the expected odd_and_even_numbers" do
-      @code.odd_and_even_numbers.must_equal [[2,4,1,7,5,0], [1,6,8,6,7,0]]
+      assert_equal [[2,4,1,7,5,0], [1,6,8,6,7,0]], @code.odd_and_even_numbers
     end
 
     it "should have the expected left_numbers" do
-                                   #0=second number in number system code
-      @code.left_numbers.must_equal [0,7,5,6,7,8]
+      #             0=second number in number system code
+      assert_equal [0,7,5,6,7,8], @code.left_numbers
     end
 
     it "should have the expected right_numbers" do
-      @code.right_numbers.must_equal [1,6,4,1,2,5]#5=checksum
+      #                       5=checksum
+      assert_equal [1,6,4,1,2,5], @code.right_numbers
     end
 
     it "should have the expected numbers_with_checksum" do
-      @code.numbers_with_checksum.must_equal @data.split(//).map{|s| s.to_i } + [5]
+      assert_equal @data.split(//).map{|s| s.to_i } + [5], @code.numbers_with_checksum
     end
 
     it "should have the expected data_with_checksum" do
-      @code.data_with_checksum.must_equal @data+'5'
+      assert_equal @data+'5', @code.data_with_checksum
     end
 
     it "should return all digits and the checksum on to_s" do
-      @code.to_s.must_equal '0075678164125'
+      assert_equal '0075678164125', @code.to_s
     end
 
   end
@@ -87,19 +90,19 @@ class EAN13Test < Barby::TestCase
     end
 
     it "should have the expected weighted_sum" do
-      @code.weighted_sum.must_equal 85
+      assert_equal 85, @code.weighted_sum
       @code.data = '007567816413'
-      @code.weighted_sum.must_equal 88
+      assert_equal 88, @code.weighted_sum
     end
 
     it "should have the correct checksum" do
-      @code.checksum.must_equal 5
+      assert_equal 5, @code.checksum
       @code.data = '007567816413'
-      @code.checksum.must_equal 2
+      assert_equal 2, @code.checksum
     end
 
     it "should have the correct checksum_encoding" do
-      @code.checksum_encoding.must_equal '1001110'
+      assert_equal '1001110', @code.checksum_encoding
     end
 
   end
@@ -111,36 +114,36 @@ class EAN13Test < Barby::TestCase
     end
 
     it "should have the expected checksum" do
-      @code.checksum.must_equal 9
+      assert_equal 9, @code.checksum
     end
 
     it "should have the expected checksum_encoding" do
-      @code.checksum_encoding.must_equal '1110100'
+      assert_equal '1110100', @code.checksum_encoding
     end
 
     it "should have the expected left_parity_map" do
-      @code.left_parity_map.must_equal [:odd, :even, :odd, :even, :odd, :even]
+      assert_equal [:odd, :even, :odd, :even, :odd, :even], @code.left_parity_map
     end
 
     it "should have the expected left_encodings" do
-      @code.left_encodings.must_equal %w(0110001 0100111 0011001 0100111 0111101 0110011)
+      assert_equal %w(0110001 0100111 0011001 0100111 0111101 0110011), @code.left_encodings
     end
 
     it "should have the expected right_encodings" do
-      @code.right_encodings.must_equal %w(1000010 1100110 1100110 1000010 1110010 1110100)
+      assert_equal %w(1000010 1100110 1100110 1000010 1110010 1110100), @code.right_encodings
     end
 
     it "should have the expected left_encoding" do
-      @code.left_encoding.must_equal '011000101001110011001010011101111010110011'
+      assert_equal '011000101001110011001010011101111010110011', @code.left_encoding
     end
 
     it "should have the expected right_encoding" do
-      @code.right_encoding.must_equal '100001011001101100110100001011100101110100'
+      assert_equal '100001011001101100110100001011100101110100', @code.right_encoding
     end
 
     it "should have the expected encoding" do
-                               #Start   Left                                           Center    Right                                          Stop
-      @code.encoding.must_equal '101' + '011000101001110011001010011101111010110011' + '01010' + '100001011001101100110100001011100101110100' + '101'
+      #            Start   Left                                           Center    Right                                          Stop
+      assert_equal '101' + '011000101001110011001010011101111010110011' + '01010' + '100001011001101100110100001011100101110100' + '101', @code.encoding
     end
 
   end
@@ -152,15 +155,15 @@ class EAN13Test < Barby::TestCase
     end
 
     it "should have the expected start_encoding" do
-      @code.start_encoding.must_equal '101'
+      assert_equal '101', @code.start_encoding
     end
 
     it "should have the expected stop_encoding" do
-      @code.stop_encoding.must_equal '101'
+      assert_equal '101', @code.stop_encoding
     end
 
     it "should have the expected center_encoding" do
-      @code.center_encoding.must_equal '01010'
+      assert_equal '01010', @code.center_encoding
     end
 
   end

data/test/ean8_test.rb

@@ -37,11 +37,11 @@ class EAN8Test < Barby::TestCase
     end
 
     it "should have the expected weighted_sum" do
-      @code.weighted_sum.must_equal 53
+      assert_equal 53, @code.weighted_sum
     end
 
     it "should have the expected checksum" do
-      @code.checksum.must_equal 7
+      assert_equal 7, @code.checksum
     end
 
   end
@@ -54,24 +54,24 @@ class EAN8Test < Barby::TestCase
     end
 
     it "should have the expected data" do
-      @code.data.must_equal @data
+      assert_equal @data, @code.data
     end
 
     it "should have the expected odd_and_even_numbers" do
-      @code.odd_and_even_numbers.must_equal [[5,3,1,5],[4,2,5]]
+      assert_equal [[5,3,1,5],[4,2,5]], @code.odd_and_even_numbers
     end
 
     it "should have the expected left_numbers" do
       #EAN-8 includes the first character in the left-hand encoding, unlike EAN-13
-      @code.left_numbers.must_equal [5,5,1,2]
+      assert_equal [5,5,1,2], @code.left_numbers
     end
 
     it "should have the expected right_numbers" do
-      @code.right_numbers.must_equal [3,4,5,7]
+      assert_equal [3,4,5,7], @code.right_numbers
     end
 
     it "should return the data with checksum on to_s" do
-      @code.to_s.must_equal '55123457'
+      assert_equal '55123457', @code.to_s
     end
 
   end
@@ -83,15 +83,15 @@ class EAN8Test < Barby::TestCase
     end
 
     it "should have the expected left_parity_map" do
-      @code.left_parity_map.must_equal [:odd, :odd, :odd, :odd]
+      assert_equal [:odd, :odd, :odd, :odd], @code.left_parity_map
     end
 
     it "should have the expected left_encoding" do
-      @code.left_encoding.must_equal '0110001011000100110010010011'
+      assert_equal '0110001011000100110010010011', @code.left_encoding
     end
 
     it "should have the expected right_encoding" do
-      @code.right_encoding.must_equal '1000010101110010011101000100'
+      assert_equal '1000010101110010011101000100', @code.right_encoding
     end
 
   end

data/test/outputter/cairo_outputter_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 class CairoOutputterTest < Barby::TestCase
-  
+
   def ps_available?
     Cairo.const_defined?(:PSSurface)
   end
@@ -29,62 +29,62 @@ class CairoOutputterTest < Barby::TestCase
   end
 
   it "should have defined the render_to_cairo_context method" do
-    @outputters.must_include(:render_to_cairo_context)
+    assert @outputters.include?(:render_to_cairo_context)
   end
 
   it "should have defined the to_png method" do
-    @outputters.must_include(:to_png)
+    assert @outputters.include?(:to_png)
   end
 
   it "should have defined the to_ps and to_eps method if available" do
     if ps_available?
-      @outputters.must_include(:to_ps)
+      assert @outputters.include?(:to_ps)
       if eps_available?
-        @outputters.must_include(:to_eps)
+        assert @outputters.include?(:to_eps)
       else
-        @outputters.wont_include(:to_eps)
+        refute @outputters.include?(:to_eps)
       end
     else
-      @outputters.wont_include(:to_ps)
-      @outputters.wont_include(:to_eps)
+      refute @outputters.include?(:to_ps)
+      refute @outputters.include?(:to_eps)
     end
   end
 
   it "should have defined the to_pdf method if available" do
     if pdf_available?
-      @outputters.must_include(:to_pdf)
+      assert @outputters.include?(:to_pdf)
     else
-      @outputters.wont_include(:to_pdf)
+      refute @outputters.include?(:to_pdf)
     end
   end
 
   it "should have defined the to_svg method if available" do
     if svg_available?
-      @outputters.must_include(:to_svg)
+      assert @outputters.include?(:to_svg)
     else
-      @outputters.wont_include(:to_svg)
+      refute @outputters.include?(:to_svg)
     end
   end
 
   it "should return the cairo context object it was given in render_to_cairo_context" do
-    @barcode.render_to_cairo_context(@context).object_id.must_equal @context.object_id
+    assert_equal @context.object_id, @barcode.render_to_cairo_context(@context).object_id
   end
 
   it "should return PNG image by the to_png method" do
     png = @barcode.to_png
     data = ruby_19_or_greater? ? png.force_encoding('BINARY') : png
-    data.must_match(/\A\x89PNG/n)
+    assert_match /\A\x89PNG/n, data
   end
 
   it "should return PS document by the to_ps method" do
     if ps_available?
-      @barcode.to_ps.must_match(/\A%!PS-Adobe-[\d.]/)
+      assert_match /\A%!PS-Adobe-[\d.]/, @barcode.to_ps
     end
   end
 
   it "should return EPS document by the to_eps method" do
     if eps_available?
-      @barcode.to_eps.must_match(/\A%!PS-Adobe-[\d.]+ EPSF-[\d.]+/)
+      assert_match /\A%!PS-Adobe-[\d.]+ EPSF-[\d.]+/, @barcode.to_eps
     end
   end
 
@@ -92,38 +92,40 @@ class CairoOutputterTest < Barby::TestCase
     if pdf_available?
       pdf = @barcode.to_pdf
       data = ruby_19_or_greater? ? pdf.force_encoding('BINARY') : pdf
-      data.must_match(/\A%PDF-[\d.]+/n)
+      assert_match /\A%PDF-[\d.]+/n, data
     end
   end
 
   it "should return SVG document by the to_svg method" do
     if svg_available?
-      @barcode.to_svg.must_match(/<\/svg>\s*\Z/m)
+      assert_match /<\/svg>\s*\Z/m, @barcode.to_svg
     end
   end
 
   it "should have x, y, width, height, full_width, full_height, xdim and margin attributes" do
-    @outputter.must_respond_to(:x)
-    @outputter.must_respond_to(:y)
-    @outputter.must_respond_to(:width)
-    @outputter.must_respond_to(:height)
-    @outputter.must_respond_to(:full_width)
-    @outputter.must_respond_to(:full_height)
-    @outputter.must_respond_to(:xdim)
-    @outputter.must_respond_to(:margin)
+    assert @outputter.respond_to?(:x)
+    assert @outputter.respond_to?(:y)
+    assert @outputter.respond_to?(:width)
+    assert @outputter.respond_to?(:height)
+    assert @outputter.respond_to?(:full_width)
+    assert @outputter.respond_to?(:full_height)
+    assert @outputter.respond_to?(:xdim)
+    assert @outputter.respond_to?(:margin)
   end
 
   it "should not change attributes when given an options hash to render" do
     %w(x y height xdim).each do |m|
       @outputter.send("#{m}=", 10)
-      @outputter.send(m).must_equal 10
+      assert_equal 10, @outputter.send(m)
     end
     @outputter.render_to_cairo_context(@context,
                                        :x => 20,
                                        :y => 20,
                                        :height => 20,
                                        :xdim => 20)
-    %w(x y height xdim).each{|m| @outputter.send(m).must_equal 10 }
+    %w(x y height xdim).each do |m|
+      assert_equal 10, @outputter.send(m)
+    end
   end
-  
+
 end

data/test/outputter/html_outputter_test.rb

@@ -1,6 +1,5 @@
 require 'test_helper'
 require 'barby/barcode/code_128'
-#require 'barby/outputter/html_outputter'
 
 class HtmlOutputterTest < Barby::TestCase
 
@@ -21,7 +20,7 @@ class HtmlOutputterTest < Barby::TestCase
   end
 
   it "should register to_html" do
-    Barcode.outputters.must_include(:to_html)
+    assert Barcode.outputters.include?(:to_html)
   end
 
   it 'should have the expected start HTML' do

data/test/outputter/pdfwriter_outputter_test.rb

@@ -14,22 +14,22 @@ unless RUBY_VERSION >= '1.9'
     end
 
     it "should have registered annotate_pdf" do
-      Barcode.outputters.must_include(:annotate_pdf)
+      assert Barcode.outputters.include?(:annotate_pdf)
     end
 
     it "should have defined the annotate_pdf method" do
-      @outputter.must_respond_to(:annotate_pdf)
+      assert @outputter.respond_to?(:annotate_pdf)
     end
 
     it "should return the pdf object it was given in annotate_pdf" do
-      @barcode.annotate_pdf(@pdf).object_id.must_equal @pdf.object_id
+      assert_equal @pdf.object_id, @barcode.annotate_pdf(@pdf).object_id
     end
 
     it "should have x, y, height and xdim attributes" do
-      @outputter.must_respond_to(:x)
-      @outputter.must_respond_to(:y)
-      @outputter.must_respond_to(:height)
-      @outputter.must_respond_to(:xdim)
+      assert @outputter.respond_to?(:x)
+      assert @outputter.respond_to?(:y)
+      assert @outputter.respond_to?(:height)
+      assert @outputter.respond_to?(:xdim)
     end
 
   end

data/test/outputter/png_outputter_test.rb

@@ -16,34 +16,34 @@ class PngOutputterTest < Barby::TestCase
     @barcode = PngTestBarcode.new('10110011100011110000')
     @outputter = PngOutputter.new(@barcode)
   end
-  
+
   it "should register to_png and to_image" do
-    Barcode.outputters.must_include(:to_png)
-    Barcode.outputters.must_include(:to_image)
+    assert Barcode.outputters.include?(:to_png)
+    assert Barcode.outputters.include?(:to_image)
   end
 
   it "should return a ChunkyPNG::Datastream on to_datastream" do
-    @barcode.to_datastream.must_be_instance_of(ChunkyPNG::Datastream)
+    assert @barcode.to_datastream.is_a?(ChunkyPNG::Datastream)
   end
 
   it "should return a string on to_png" do
-    @barcode.to_png.must_be_instance_of(String)
+    assert @barcode.to_png.is_a?(String)
   end
 
   it "should return a ChunkyPNG::Image on to_canvas" do
-    @barcode.to_image.must_be_instance_of(ChunkyPNG::Image)
+    assert @barcode.to_image.is_a?(ChunkyPNG::Image)
   end
 
   it "should have a width equal to Xdim * barcode_string.length" do
-    @outputter.width.must_equal @outputter.barcode.encoding.length * @outputter.xdim
+    assert_equal @outputter.barcode.encoding.length * @outputter.xdim, @outputter.width
   end
 
   it "should have a full_width which is the sum of width + (margin*2)" do
-    @outputter.full_width.must_equal @outputter.width + (@outputter.margin*2)
+    assert_equal(@outputter.width + (@outputter.margin*2), @outputter.full_width)
   end
 
   it "should have a full_height which is the sum of height + (margin*2)" do
-    @outputter.full_height.must_equal @outputter.height + (@outputter.margin*2)
+    assert_equal(@outputter.height + (@outputter.margin*2), @outputter.full_height)
   end
 
 end

data/test/outputter/prawn_outputter_test.rb

@@ -10,70 +10,70 @@ class PrawnOutputterTest < Barby::TestCase
   end
 
   it "should register to_pdf and annotate_pdf" do
-    Barcode.outputters.must_include(:to_pdf)
-    Barcode.outputters.must_include(:annotate_pdf)
+    assert Barcode.outputters.include?(:to_pdf)
+    assert Barcode.outputters.include?(:annotate_pdf)
   end
 
   it "should have a to_pdf method" do
-    @outputter.must_respond_to(:to_pdf)
+    assert @outputter.respond_to?(:to_pdf)
   end
 
   it "should return a PDF document in a string on to_pdf" do
-    @barcode.to_pdf.must_be_instance_of(String)
+    assert @barcode.to_pdf.is_a?(String)
   end
 
   it "should return the same Prawn::Document on annotate_pdf" do
     doc = Prawn::Document.new
-    @barcode.annotate_pdf(doc).object_id.must_equal doc.object_id
+    assert_equal doc.object_id, @barcode.annotate_pdf(doc).object_id
   end
 
   it "should default x and y to margin value" do
     @outputter.margin = 123
-    @outputter.x.must_equal 123
-    @outputter.y.must_equal 123
+    assert_equal 123, @outputter.x
+    assert_equal 123, @outputter.y
   end
 
   it "should default ydim to xdim value" do
     @outputter.xdim = 321
-    @outputter.ydim.must_equal 321
+    assert_equal 321, @outputter.ydim
   end
 
   it "should be able to calculate width required" do
-    @outputter.width.must_equal @barcode.encoding.length
+    assert_equal @barcode.encoding.length, @outputter.width
     @outputter.xdim = 2
-    @outputter.width.must_equal @barcode.encoding.length * 2
-    @outputter.full_width.must_equal @barcode.encoding.length * 2
+    assert_equal @barcode.encoding.length * 2, @outputter.width
+    assert_equal @barcode.encoding.length * 2, @outputter.full_width
     @outputter.margin = 5
-    @outputter.full_width.must_equal((@barcode.encoding.length * 2) + 10)
+    assert_equal((@barcode.encoding.length * 2) + 10, @outputter.full_width)
 
     #2D
     barcode = Barcode2D.new
     def barcode.encoding; ['111', '000', '111'] end
     outputter = PrawnOutputter.new(barcode)
-    outputter.width.must_equal 3
+    assert_equal 3, outputter.width
     outputter.xdim = 2
     outputter.margin = 5
-    outputter.width.must_equal 6
-    outputter.full_width.must_equal 16
+    assert_equal 6, outputter.width
+    assert_equal 16, outputter.full_width
   end
 
   it "should be able to calculate height required" do
-    @outputter.full_height.must_equal @outputter.height
+    assert_equal @outputter.height, @outputter.full_height
     @outputter.margin = 5
-    @outputter.full_height.must_equal @outputter.height + 10
+    assert_equal @outputter.height + 10, @outputter.full_height
 
     #2D
     barcode = Barcode2D.new
     def barcode.encoding; ['111', '000', '111'] end
     outputter = PrawnOutputter.new(barcode)
-    outputter.height.must_equal 3
+    assert_equal 3, outputter.height
     outputter.xdim = 2 #ydim defaults to xdim
     outputter.margin = 5
-    outputter.height.must_equal 6
-    outputter.full_height.must_equal 16
+    assert_equal 6, outputter.height
+    assert_equal 16, outputter.full_height
     outputter.ydim = 3 #ydim overrides xdim when set
-    outputter.height.must_equal 9
-    outputter.full_height.must_equal 19
+    assert_equal 9, outputter.height
+    assert_equal 19, outputter.full_height
   end
 
 end

data/test/outputter/rmagick_outputter_test.rb

@@ -18,49 +18,49 @@ class RmagickOutputterTest < Barby::TestCase
   end
 
   it "should register to_png, to_gif, to_jpg, to_image" do
-    Barcode.outputters.must_include(:to_png)
-    Barcode.outputters.must_include(:to_gif)
-    Barcode.outputters.must_include(:to_jpg)
-    Barcode.outputters.must_include(:to_image)
+    assert Barcode.outputters.include?(:to_png)
+    assert Barcode.outputters.include?(:to_gif)
+    assert Barcode.outputters.include?(:to_jpg)
+    assert Barcode.outputters.include?(:to_image)
   end
 
   it "should have defined to_png, to_gif, to_jpg, to_image" do
-    @outputter.must_respond_to(:to_png)
-    @outputter.must_respond_to(:to_gif)
-    @outputter.must_respond_to(:to_jpg)
-    @outputter.must_respond_to(:to_image)
+    assert @outputter.respond_to?(:to_png)
+    assert @outputter.respond_to?(:to_gif)
+    assert @outputter.respond_to?(:to_jpg)
+    assert @outputter.respond_to?(:to_image)
   end
 
   it "should return a string on to_png and to_gif" do
-    @outputter.to_png.must_be_instance_of(String)
-    @outputter.to_gif.must_be_instance_of(String)
+    assert @outputter.to_png.is_a?(String)
+    assert @outputter.to_gif.is_a?(String)
   end
 
   it "should return a Magick::Image instance on to_image" do
-    @outputter.to_image.must_be_instance_of(Magick::Image)
+    assert @outputter.to_image.is_a?(Magick::Image)
   end
 
   it "should have a width equal to the length of the barcode encoding string * x dimension" do
-    @outputter.xdim.must_equal 1#Default
-    @outputter.width.must_equal @outputter.barcode.encoding.length
+    assert_equal 1, @outputter.xdim #Default
+    assert_equal @outputter.barcode.encoding.length, @outputter.width
     @outputter.xdim = 2
-    @outputter.width.must_equal @outputter.barcode.encoding.length * 2
+    assert_equal @outputter.barcode.encoding.length * 2, @outputter.width
   end
 
   it "should have a full_width equal to the width + left and right margins" do
-    @outputter.xdim.must_equal 1
-    @outputter.margin.must_equal 10
-    @outputter.full_width.must_equal (@outputter.width + 10 + 10)
+    assert_equal 1, @outputter.xdim
+    assert_equal 10, @outputter.margin
+    assert_equal((@outputter.width + 10 + 10), @outputter.full_width)
   end
 
   it "should have a default height of 100" do
-    @outputter.height.must_equal 100
+    assert_equal 100, @outputter.height
     @outputter.height = 200
-    @outputter.height.must_equal 200
+    assert_equal 200, @outputter.height
   end
 
   it "should have a full_height equal to the height + top and bottom margins" do
-    @outputter.full_height.must_equal @outputter.height + (@outputter.margin * 2)
+    assert_equal(@outputter.height + (@outputter.margin * 2), @outputter.full_height)
   end
 
   describe "#to_image" do
@@ -72,8 +72,8 @@ class RmagickOutputterTest < Barby::TestCase
     end
 
     it "should have a width and height equal to the outputter's full_width and full_height" do
-      @image.columns.must_equal @outputter.full_width
-      @image.rows.must_equal @outputter.full_height
+      assert_equal @outputter.full_width, @image.columns
+      assert_equal @outputter.full_height, @image.rows
     end
 
   end