barby 0.6.8 → 0.7.0

data/test/code_25_test.rb

@@ -9,75 +9,75 @@ class Code25Test < Barby::TestCase
   end
 
   it "should return the same data it was given" do
-    @code.data.must_equal @data
+    assert_equal @data, @code.data
   end
 
   it "should have the expected characters" do
-    @code.characters.must_equal %w(1 2 3 4 5 6 7)
+    assert_equal %w(1 2 3 4 5 6 7), @code.characters
   end
 
   it "should have the expected characters_with_checksum" do
-    @code.characters_with_checksum.must_equal %w(1 2 3 4 5 6 7 0)
+    assert_equal %w(1 2 3 4 5 6 7 0), @code.characters_with_checksum
   end
 
   it "should have the expected digits" do
-    @code.digits.must_equal [1,2,3,4,5,6,7]
+    assert_equal [1,2,3,4,5,6,7], @code.digits
   end
 
   it "should have the expected digits_with_checksum" do
-    @code.digits_with_checksum.must_equal [1,2,3,4,5,6,7,0]
+    assert_equal [1,2,3,4,5,6,7,0], @code.digits_with_checksum
   end
 
   it "should have the expected even_and_odd_digits" do
-    @code.even_and_odd_digits.must_equal [[7,5,3,1], [6,4,2]]
+    assert_equal [[7,5,3,1], [6,4,2]], @code.even_and_odd_digits
   end
 
   it "should have the expected start_encoding" do
-    @code.start_encoding.must_equal '1110111010'
+    assert_equal '1110111010', @code.start_encoding
   end
 
   it "should have the expected stop_encoding" do
-    @code.stop_encoding.must_equal '111010111'
+    assert_equal '111010111', @code.stop_encoding
   end
 
   it "should have a default narrow_width of 1" do
-    @code.narrow_width.must_equal 1
+    assert_equal 1, @code.narrow_width
   end
 
   it "should have a default wide_width equal to narrow_width * 3" do
-    @code.wide_width.must_equal @code.narrow_width * 3
+    assert_equal @code.narrow_width * 3, @code.wide_width
     @code.narrow_width = 2
-    @code.wide_width.must_equal 6
+    assert_equal 6, @code.wide_width
   end
 
   it "should have a default space_width equal to narrow_width" do
-    @code.space_width.must_equal @code.narrow_width
+    assert_equal @code.narrow_width, @code.space_width
     @code.narrow_width = 23
-    @code.space_width.must_equal 23
+    assert_equal 23, @code.space_width
   end
 
   it "should have the expected digit_encodings" do
-    @code.digit_encodings.must_equal %w(11101010101110 10111010101110 11101110101010 10101110101110 11101011101010 10111011101010 10101011101110)
+    assert_equal %w(11101010101110 10111010101110 11101110101010 10101110101110 11101011101010 10111011101010 10101011101110), @code.digit_encodings
   end
 
   it "should have the expected digit_encodings_with_checksum" do
-    @code.digit_encodings_with_checksum.must_equal %w(11101010101110 10111010101110 11101110101010 10101110101110 11101011101010 10111011101010 10101011101110 10101110111010)
+    assert_equal %w(11101010101110 10111010101110 11101110101010 10101110101110 11101011101010 10111011101010 10101011101110 10101110111010), @code.digit_encodings_with_checksum
   end
 
   it "should have the expected data_encoding" do
-    @code.data_encoding.must_equal "11101010101110101110101011101110111010101010101110101110111010111010101011101110101010101011101110"
+    assert_equal "11101010101110101110101011101110111010101010101110101110111010111010101011101110101010101011101110", @code.data_encoding
   end
 
   it "should have the expected checksum" do
-    @code.checksum.must_equal 0
+    assert_equal 0, @code.checksum
   end
 
   it "should have the expected checksum_encoding" do
-    @code.checksum_encoding.must_equal '10101110111010'
+    assert_equal '10101110111010', @code.checksum_encoding
   end
 
   it "should have the expected encoding" do
-    @code.encoding.must_equal "111011101011101010101110101110101011101110111010101010101110101110111010111010101011101110101010101011101110111010111"
+    assert_equal "111011101011101010101110101110101011101110111010101010101110101110111010111010101011101110101010101011101110111010111", @code.encoding
   end
 
   it "should be valid" do
@@ -91,20 +91,30 @@ class Code25Test < Barby::TestCase
 
   it "should raise on encoding methods that include data encoding if not valid" do
     @code.data = 'abc'
-    lambda{ @code.encoding }.must_raise ArgumentError
-    lambda{ @code.data_encoding }.must_raise ArgumentError
-    lambda{ @code.data_encoding_with_checksum }.must_raise ArgumentError
-    lambda{ @code.digit_encodings }.must_raise ArgumentError
-    lambda{ @code.digit_encodings_with_checksum }.must_raise ArgumentError
+    assert_raises ArgumentError do
+      @code.encoding
+    end
+    assert_raises ArgumentError do
+      @code.data_encoding
+    end
+    assert_raises ArgumentError do
+      @code.data_encoding_with_checksum
+    end
+    assert_raises ArgumentError do
+      @code.digit_encodings
+    end
+    assert_raises ArgumentError do
+      @code.digit_encodings_with_checksum
+    end
   end
 
   it "should return all characters in sequence on to_s" do
-    @code.to_s.must_equal @code.characters.join
+    assert_equal @code.characters.join, @code.to_s
   end
 
   it "should include checksum in to_s when include_checksum is true" do
     @code.include_checksum = true
-    @code.to_s.must_equal @code.characters_with_checksum.join
+    assert_equal @code.characters_with_checksum.join, @code.to_s
   end
 
 end

data/test/code_39_test.rb

@@ -13,39 +13,39 @@ class Code39Test < Barby::TestCase
   it "should yield self on initialize" do
     c1 = nil
     c2 = Code39.new('TEST'){|c| c1 = c }
-    c1.must_equal c2
+    assert_equal c2, c1
   end
 
   it "should have the expected data" 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 start_encoding" do
-    @code.start_encoding.must_equal '100101101101'
+    assert_equal '100101101101', @code.start_encoding
   end
 
   it "should have the expected stop_encoding" do
-    @code.stop_encoding.must_equal '100101101101'
+    assert_equal '100101101101', @code.stop_encoding
   end
 
   it "should have the expected spacing_encoding" do
-    @code.spacing_encoding.must_equal '000'
+    assert_equal '000', @code.spacing_encoding
   end
 
   it "should have the expected encoded characters" do
-    @code.encoded_characters.must_equal %w(101011011001 110101100101 101101011001 101011011001 110100101101 101001101101 110100110101 101100101011)
+    assert_equal %w(101011011001 110101100101 101101011001 101011011001 110100101101 101001101101 110100110101 101100101011), @code.encoded_characters
   end
 
   it "should have the expected data_encoding" do
-    @code.data_encoding.must_equal '101011011001000110101100101000101101011001000101011011001000110100101101000101001101101000110100110101000101100101011'
+    assert_equal '101011011001000110101100101000101101011001000101011011001000110100101101000101001101101000110100110101000101100101011', @code.data_encoding
   end
 
   it "should have the expected encoding" do
-    @code.encoding.must_equal '100101101101000101011011001000110101100101000101101011001000101011011001000110100101101000101001101101000110100110101000101100101011000100101101101'
+    assert_equal '100101101101000101011011001000110101100101000101101011001000101011011001000110100101101000101001101101000110100110101000101100101011000100101101101', @code.encoding
   end
 
   it "should be valid" do
@@ -58,13 +58,15 @@ class Code39Test < Barby::TestCase
   end
 
   it "should raise an exception when data is not valid on initialization" do
-    lambda{ Code39.new('abc') }.must_raise(ArgumentError)
+    assert_raises ArgumentError do
+      Code39.new('abc')
+    end
   end
 
   it "should return all characters in sequence without checksum on to_s" do
-    @code.to_s.must_equal @data
+    assert_equal @data, @code.to_s
   end
-  
+
   describe "Checksumming" do
 
     before do
@@ -72,36 +74,36 @@ class Code39Test < Barby::TestCase
     end
 
     it "should have the expected checksum" do
-      @code.checksum.must_equal 32
+      assert_equal 32, @code.checksum
     end
 
     it "should have the expected checksum_character" do
-      @code.checksum_character.must_equal 'W'
+      assert_equal 'W', @code.checksum_character
     end
 
     it "should have the expected checksum_encoding" do
-      @code.checksum_encoding.must_equal '110011010101'
+      assert_equal '110011010101', @code.checksum_encoding
     end
 
     it "should have the expected characters_with_checksum" do
-      @code.characters_with_checksum.must_equal %w(C O D E 3 9 W)
+      assert_equal %w(C O D E 3 9 W), @code.characters_with_checksum
     end
 
     it "should have the expected encoded_characters_with_checksum" do
-      @code.encoded_characters_with_checksum.must_equal %w(110110100101 110101101001 101011001011 110101100101 110110010101 101100101101 110011010101)
+      assert_equal %w(110110100101 110101101001 101011001011 110101100101 110110010101 101100101101 110011010101), @code.encoded_characters_with_checksum
     end
 
     it "should have the expected data_encoding_with_checksum" do
-      @code.data_encoding_with_checksum.must_equal "110110100101011010110100101010110010110110101100101011011001010101011001011010110011010101"
+      assert_equal "110110100101011010110100101010110010110110101100101011011001010101011001011010110011010101", @code.data_encoding_with_checksum
     end
 
     it "should have the expected encoding_with_checksum" do
-      @code.encoding_with_checksum.must_equal "10010110110101101101001010110101101001010101100101101101011001010110110010101010110010110101100110101010100101101101"
+      assert_equal "10010110110101101101001010110101101001010101100101101101011001010110110010101010110010110101100110101010100101101101", @code.encoding_with_checksum
     end
 
     it "should return the encoding with checksum when include_checksum == true" do
       @code.include_checksum = true
-      @code.encoding.must_equal "10010110110101101101001010110101101001010101100101101101011001010110110010101010110010110101100110101010100101101101"
+      assert_equal "10010110110101101101001010110101101001010101100101101101011001010110110010101010110010110101100110101010100101101101", @code.encoding
     end
 
   end
@@ -114,15 +116,15 @@ class Code39Test < Barby::TestCase
     end
 
     it "should have the expected characters" do
-      @code.characters.must_equal %w(A B C $ %)
+      assert_equal %w(A B C $ %), @code.characters
     end
 
     it "should have the expected encoded_characters" do
-      @code.encoded_characters.must_equal %w(110101001011 101101001011 110110100101 100100100101 101001001001)
+      assert_equal %w(110101001011 101101001011 110110100101 100100100101 101001001001), @code.encoded_characters
     end
 
     it "should have the expected data_encoding" do
-      @code.data_encoding.must_equal '1101010010110101101001011011011010010101001001001010101001001001'
+      assert_equal '1101010010110101101001011011011010010101001001001010101001001001', @code.data_encoding
     end
 
     it "should not be valid" do
@@ -144,20 +146,21 @@ class Code39Test < Barby::TestCase
     end
 
     it "should have the expected characters" do
-      @code.characters.must_equal %w(% G + A + B + C % I)
+      assert_equal %w(% G + A + B + C % I), @code.characters
     end
 
     it "should have the expected encoded_characters" do
-      @code.encoded_characters.must_equal %w(101001001001 101010011011 100101001001 110101001011 100101001001 101101001011 100101001001 110110100101 101001001001 101101001101)
+      assert_equal %w(101001001001 101010011011 100101001001 110101001011 100101001001 101101001011 100101001001 110110100101 101001001001 101101001101), @code.encoded_characters
     end
 
     it "should have the expected data_encoding" do
-      @code.data_encoding.must_equal '101001001001010101001101101001010010010110101001011010010100100101011010010110100101001001011011010010101010010010010101101001101'
+      assert_equal '101001001001010101001101101001010010010110101001011010010100100101011010010110100101001001011011010010101010010010010101101001101', @code.data_encoding
     end
 
     it "should have the expected encoding" do
-      @code.encoding.must_equal '10010110110101010010010010101010011011010010100100101101010010110100101001001'+
-                               '010110100101101001010010010110110100101010100100100101011010011010100101101101'
+      assert_equal '10010110110101010010010010101010011011010010100100101101010010110100101001001'+
+                   '010110100101101001010010010110110100101010100100100101011010011010100101101101',
+                   @code.encoding
     end
 
     it "should take a second parameter on initialize indicating it is extended" do
@@ -176,7 +179,7 @@ class Code39Test < Barby::TestCase
     end
 
     it "should return all characters in sequence without checksum on to_s" do
-      @code.to_s.must_equal @data
+      assert_equal @data, @code.to_s
     end
 
   end
@@ -191,16 +194,16 @@ class Code39Test < Barby::TestCase
     end
 
     it "should have the expected encoded_characters" do
-      @code.encoded_characters.must_equal %w(111110011001100000110011111 110011111001100000110011111 111110011111001100000110011 110000011000001100000110011 110011000001100000110000011)
+      assert_equal %w(111110011001100000110011111 110011111001100000110011111 111110011111001100000110011 110000011000001100000110011 110011000001100000110000011), @code.encoded_characters
     end
 
     it "should have the expected data_encoding" do
       #                              A                          SB                          SC                          S$                          S%
-      @code.data_encoding.must_equal '1111100110011000001100111110110011111001100000110011111011111001111100110000011001101100000110000011000001100110110011000001100000110000011'
+      assert_equal '1111100110011000001100111110110011111001100000110011111011111001111100110000011001101100000110000011000001100110110011000001100000110000011', @code.data_encoding
 
       @code.spacing = 3
       #                              A                          S  B                          S  C                          S  $                          S  %
-      @code.data_encoding.must_equal '111110011001100000110011111000110011111001100000110011111000111110011111001100000110011000110000011000001100000110011000110011000001100000110000011'
+      assert_equal '111110011001100000110011111000110011111001100000110011111000111110011111001100000110011000110000011000001100000110011000110011000001100000110000011', @code.data_encoding
     end
 
   end

data/test/code_93_test.rb

@@ -10,88 +10,90 @@ class Code93Test < Barby::TestCase
   end
 
   it "should return the same data we put in" 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 start_encoding" do
-    @code.start_encoding.must_equal '101011110'
+    assert_equal '101011110', @code.start_encoding
   end
 
   it "should have the expected stop_encoding" do
     #                              STOP     TERM
-    @code.stop_encoding.must_equal '1010111101'
+    assert_equal '1010111101', @code.stop_encoding
   end
 
   it "should have the expected encoded characters" do
     #                                     T         E         S         T         9         3
-    @code.encoded_characters.must_equal %w(110100110 110010010 110101100 110100110 100001010 101000010)
+    assert_equal %w(110100110 110010010 110101100 110100110 100001010 101000010), @code.encoded_characters
   end
 
   it "should have the expected data_encoding" do
     #                              T        E        S        T        9        3
-    @code.data_encoding.must_equal "110100110110010010110101100110100110100001010101000010"
+    assert_equal "110100110110010010110101100110100110100001010101000010", @code.data_encoding
   end
 
   it "should have the expected data_encoding_with_checksums" do
     #                                             T        E        S        T        9        3        + (C)    6 (K)
-    @code.data_encoding_with_checksums.must_equal "110100110110010010110101100110100110100001010101000010101110110100100010"
+    assert_equal "110100110110010010110101100110100110100001010101000010101110110100100010", @code.data_encoding_with_checksums
   end
 
   it "should have the expected encoding" do
     #                         START    T        E        S        T        9        3        + (C)    6 (K)    STOP     TERM
-    @code.encoding.must_equal "1010111101101001101100100101101011001101001101000010101010000101011101101001000101010111101"
+    assert_equal "1010111101101001101100100101101011001101001101000010101010000101011101101001000101010111101", @code.encoding
   end
 
   it "should have the expected checksum_values" do
-    @code.checksum_values.must_equal [29, 14, 28, 29, 9, 3].reverse #!
+    assert_equal [29, 14, 28, 29, 9, 3].reverse, @code.checksum_values #!
   end
 
   it "should have the expected c_checksum" do
-    @code.c_checksum.must_equal 41 #calculate this first!
+    assert_equal 41, #calculate this first!
+      @code.c_checksum
   end
 
   it "should have the expected c_checksum_character" do
-    @code.c_checksum_character.must_equal '+'
+    assert_equal '+', @code.c_checksum_character
   end
 
   it "should have the expected c_checksum_encoding" do
-    @code.c_checksum_encoding.must_equal '101110110'
+    assert_equal '101110110', @code.c_checksum_encoding
   end
 
   it "should have the expected checksum_values_with_c_checksum" do
-    @code.checksum_values_with_c_checksum.must_equal [29, 14, 28, 29, 9, 3, 41].reverse #!
+    assert_equal [29, 14, 28, 29, 9, 3, 41].reverse, @code.checksum_values_with_c_checksum #!
   end
 
   it "should have the expected k_checksum" do
-    @code.k_checksum.must_equal 6 #calculate this first!
+    assert_equal 6, #calculate this first!
+      @code.k_checksum
   end
 
   it "should have the expected k_checksum_character" do
-    @code.k_checksum_character.must_equal '6'
+    assert_equal '6', @code.k_checksum_character
   end
 
   it "should have the expected k_checksum_encoding" do
-    @code.k_checksum_encoding.must_equal '100100010'
+    assert_equal '100100010', @code.k_checksum_encoding
   end
 
   it "should have the expected checksums" do
-    @code.checksums.must_equal [41, 6]
+    assert_equal [41, 6], @code.checksums
   end
 
   it "should have the expected checksum_characters" do
-    @code.checksum_characters.must_equal ['+', '6']
+    assert_equal ['+', '6'], @code.checksum_characters
   end
 
   it "should have the expected checksum_encodings" do
-    @code.checksum_encodings.must_equal %w(101110110 100100010)
+    assert_equal %w(101110110 100100010), @code.checksum_encodings
   end
 
   it "should have the expected checksum_encoding" do
-    @code.checksum_encoding.must_equal '101110110100100010'
+    assert_equal '101110110100100010', @code.checksum_encoding
   end
 
   it "should be valid" do
@@ -103,9 +105,9 @@ class Code93Test < Barby::TestCase
   end
 
   it "should return data with no checksums on to_s" do
-    @code.to_s.must_equal 'TEST93'
+    assert_equal 'TEST93', @code.to_s
   end
-  
+
   describe "Extended mode" do
 
     before do
@@ -118,24 +120,25 @@ class Code93Test < Barby::TestCase
     end
 
     it "should convert extended characters to special shift characters" do
-      @code.characters.must_equal ["E", "\304", "X", "\304", "T", "\304", "E", "\304", "N", "\304", "D", "\304", "E", "\304", "D", "\303", "A"]
+      assert_equal ["E", "\304", "X", "\304", "T", "\304", "E", "\304", "N", "\304", "D", "\304", "E", "\304", "D", "\303", "A"], @code.characters
     end
 
     it "should have the expected data_encoding" do
-      @code.data_encoding.must_equal '110010010100110010101100110100110010110100110100110010110010010'+
-      '100110010101000110100110010110010100100110010110010010100110010110010100111010110110101000'
+      assert_equal '110010010100110010101100110100110010110100110100110010110010010'+
+                   '100110010101000110100110010110010100100110010110010010100110010110010100111010110110101000',
+                   @code.data_encoding
     end
 
     it "should have the expected c_checksum" do
-      @code.c_checksum.must_equal 9
+      assert_equal 9, @code.c_checksum
     end
 
     it "should have the expected k_checksum" do
-      @code.k_checksum.must_equal 46
+      assert_equal 46, @code.k_checksum
     end
 
     it "should return the original data on to_s with no checksums" do
-      @code.to_s.must_equal 'Extended!'
+      assert_equal 'Extended!', @code.to_s
     end
 
   end

data/test/data_matrix_test.rb

@@ -9,22 +9,33 @@ class DataMatrixTest < Barby::TestCase
   end
 
   it "should have the expected encoding" do
-    @code.encoding.must_equal ["1010101010101010", "1011111000011111", "1110111000010100",
-                              "1110100100000111", "1101111010101000", "1101111011110011",
-                              "1111111100000100", "1100101111110001", "1001000010001010",
-                              "1101010110111011", "1000000100011110", "1001010010000011",
-                              "1101100111011110", "1110111010000101", "1110010110001010",
-                              "1111111111111111"]
+    assert_equal [
+      "10101010101010",
+      "10111010000001",
+      "11100101101100",
+      "11101001110001",
+      "11010101111110",
+      "11100101100001",
+      "11011001011110",
+      "10011011010011",
+      "11011010000100",
+      "10101100101001",
+      "11011100001100",
+      "10101110110111",
+      "11000001010100",
+      "11111111111111",
+    ],
+    @code.encoding
   end
 
   it "should return data on to_s" do
-    @code.to_s.must_equal @data
+    assert_equal @data, @code.to_s
   end
 
   it "should be able to change its data" do
     prev_encoding = @code.encoding
     @code.data = "after eight"
-    @code.encoding.wont_equal prev_encoding
+    refute_equal prev_encoding, @code.encoding
   end
 
 end