barby 0.6.7 → 0.6.9

data/test/code_128_test.rb

@@ -0,0 +1,470 @@
+# encoding: UTF-8
+require 'test_helper'
+require 'barby/barcode/code_128'
+
+class Code128Test < Barby::TestCase
+
+  %w[CODEA CODEB CODEC FNC1 FNC2 FNC3 FNC4 SHIFT].each do |const|
+    const_set const, Code128.const_get(const)
+  end
+
+  before do
+    @data = 'ABC123'
+    @code = Code128A.new(@data)
+  end
+
+  it "should have the expected stop encoding (including termination bar 11)" do
+    @code.send(:stop_encoding).must_equal '1100011101011'
+  end
+
+  it "should find the right class for a character A, B or C" do
+    @code.send(:class_for, 'A').must_equal Code128A
+    @code.send(:class_for, 'B').must_equal Code128B
+    @code.send(:class_for, 'C').must_equal Code128C
+  end
+
+  it "should find the right change code for a class" do
+    @code.send(:change_code_for_class, Code128A).must_equal Code128::CODEA
+    @code.send(:change_code_for_class, Code128B).must_equal Code128::CODEB
+    @code.send(:change_code_for_class, Code128C).must_equal Code128::CODEC
+  end
+
+  it "should not allow empty data" do
+    lambda{ Code128B.new("") }.must_raise(ArgumentError)
+  end
+
+  describe "single encoding" do
+
+    before do
+      @data = 'ABC123'
+      @code = Code128A.new(@data)
+    end
+
+    it "should have the same data as when initialized" do
+      @code.data.must_equal @data
+    end
+
+    it "should be able to change its data" do
+      @code.data = '123ABC'
+      @code.data.must_equal '123ABC'
+      @code.data.wont_equal @data
+    end
+
+    it "should not have an extra" do
+      assert @code.extra.nil?
+    end
+
+    it "should have empty extra encoding" do
+      @code.extra_encoding.must_equal ''
+    end
+
+    it "should have the correct checksum" do
+      @code.checksum.must_equal 66
+    end
+
+    it "should return all data for to_s" do
+      @code.to_s.must_equal @data
+    end
+
+  end
+
+  describe "multiple encodings" do
+
+    before do
+      @data = binary_encode("ABC123\306def\3074567")
+      @code = Code128A.new(@data)
+    end
+
+    it "should be able to return full_data which includes the entire extra chain excluding charset change characters" do
+      @code.full_data.must_equal "ABC123def4567"
+    end
+
+    it "should be able to return full_data_with_change_codes which includes the entire extra chain including charset change characters" do
+      @code.full_data_with_change_codes.must_equal @data
+    end
+
+    it "should not matter if extras were added separately" do
+      code = Code128B.new("ABC")
+      code.extra = binary_encode("\3071234")
+      code.full_data.must_equal "ABC1234"
+      code.full_data_with_change_codes.must_equal binary_encode("ABC\3071234")
+      code.extra.extra = binary_encode("\306abc")
+      code.full_data.must_equal "ABC1234abc"
+      code.full_data_with_change_codes.must_equal binary_encode("ABC\3071234\306abc")
+      code.extra.extra.data = binary_encode("abc\305DEF")
+      code.full_data.must_equal "ABC1234abcDEF"
+      code.full_data_with_change_codes.must_equal binary_encode("ABC\3071234\306abc\305DEF")
+      code.extra.extra.full_data.must_equal "abcDEF"
+      code.extra.extra.full_data_with_change_codes.must_equal binary_encode("abc\305DEF")
+      code.extra.full_data.must_equal "1234abcDEF"
+      code.extra.full_data_with_change_codes.must_equal binary_encode("1234\306abc\305DEF")
+    end
+
+    it "should have a Code B extra" do
+      @code.extra.must_be_instance_of(Code128B)
+    end
+
+    it "should have a valid extra" do
+      assert @code.extra.valid?
+    end
+
+    it "the extra should also have an extra of type C" do
+      @code.extra.extra.must_be_instance_of(Code128C)
+    end
+
+    it "the extra's extra should be valid" do
+      assert @code.extra.extra.valid?
+    end
+
+    it "should not have more than two extras" do
+      assert @code.extra.extra.extra.nil?
+    end
+
+    it "should split extra data from string on data assignment" do
+      @code.data = binary_encode("123\306abc")
+      @code.data.must_equal '123'
+      @code.extra.must_be_instance_of(Code128B)
+      @code.extra.data.must_equal 'abc'
+    end
+
+    it "should be be able to change its extra" do
+      @code.extra = binary_encode("\3071234")
+      @code.extra.must_be_instance_of(Code128C)
+      @code.extra.data.must_equal '1234'
+    end
+
+    it "should split extra data from string on extra assignment" do
+      @code.extra = binary_encode("\306123\3074567")
+      @code.extra.must_be_instance_of(Code128B)
+      @code.extra.data.must_equal '123'
+      @code.extra.extra.must_be_instance_of(Code128C)
+      @code.extra.extra.data.must_equal '4567'
+    end
+
+    it "should not fail on newlines in extras" do
+      code = Code128B.new(binary_encode("ABC\305\n"))
+      code.data.must_equal "ABC"
+      code.extra.must_be_instance_of(Code128A)
+      code.extra.data.must_equal "\n"
+      code.extra.extra = binary_encode("\305\n\n\n\n\n\nVALID")
+      code.extra.extra.data.must_equal "\n\n\n\n\n\nVALID"
+    end
+
+    it "should raise an exception when extra string doesn't start with the special code character" do
+      lambda{ @code.extra = '123' }.must_raise ArgumentError
+    end
+
+    it "should have the correct checksum" do
+      @code.checksum.must_equal 84
+    end
+
+    it "should have the expected encoding" do
+                                #STARTA     A          B          C          1          2          3
+      @code.encoding.must_equal '11010000100101000110001000101100010001000110100111001101100111001011001011100'+
+                                #CODEB      d          e          f
+                                '10111101110100001001101011001000010110000100'+
+                                #CODEC      45         67
+                                '101110111101011101100010000101100'+
+                                #CHECK=84   STOP
+                                '100111101001100011101011'
+    end
+
+    it "should return all data including extras, except change codes for to_s" do
+      @code.to_s.must_equal "ABC123def4567"
+    end
+
+  end
+
+  describe "128A" do
+
+    before do
+      @data = 'ABC123'
+      @code = Code128A.new(@data)
+    end
+
+    it "should be valid when given valid data" do
+      assert @code.valid?
+    end
+
+    it "should not be valid when given invalid data" do
+      @code.data = 'abc123'
+      refute @code.valid?
+    end
+
+    it "should have the expected characters" do
+      @code.characters.must_equal %w(A B C 1 2 3)
+    end
+
+    it "should have the expected start encoding" do
+      @code.start_encoding.must_equal '11010000100'
+    end
+
+    it "should have the expected data encoding" do
+      @code.data_encoding.must_equal '101000110001000101100010001000110100111001101100111001011001011100'
+    end
+
+    it "should have the expected encoding" do
+      @code.encoding.must_equal '11010000100101000110001000101100010001000110100111001101100111001011001011100100100001101100011101011'
+    end
+
+    it "should have the expected checksum encoding" do
+      @code.checksum_encoding.must_equal '10010000110'
+    end
+
+  end
+
+  describe "128B" do
+
+    before do
+      @data = 'abc123'
+      @code = Code128B.new(@data)
+    end
+
+    it "should be valid when given valid data" do
+      assert @code.valid?
+    end
+
+    it "should not be valid when given invalid data" do
+      @code.data = binary_encode("abc£123")
+      refute @code.valid?
+    end
+
+    it "should have the expected characters" do
+      @code.characters.must_equal %w(a b c 1 2 3)
+    end
+
+    it "should have the expected start encoding" do
+      @code.start_encoding.must_equal '11010010000'
+    end
+
+    it "should have the expected data encoding" do
+      @code.data_encoding.must_equal '100101100001001000011010000101100100111001101100111001011001011100'
+    end
+
+    it "should have the expected encoding" do
+      @code.encoding.must_equal '11010010000100101100001001000011010000101100100111001101100111001011001011100110111011101100011101011'
+    end
+
+    it "should have the expected checksum encoding" do
+      @code.checksum_encoding.must_equal '11011101110'
+    end
+
+  end
+
+  describe "128C" do
+
+    before do
+      @data = '123456'
+      @code = Code128C.new(@data)
+    end
+
+    it "should be valid when given valid data" do
+      assert @code.valid?
+    end
+
+    it "should not be valid when given invalid data" do
+      @code.data = '123'
+      refute @code.valid?
+      @code.data = 'abc'
+      refute @code.valid?
+    end
+
+    it "should have the expected characters" do
+      @code.characters.must_equal %w(12 34 56)
+    end
+
+    it "should have the expected start encoding" do
+      @code.start_encoding.must_equal '11010011100'
+    end
+
+    it "should have the expected data encoding" do
+      @code.data_encoding.must_equal '101100111001000101100011100010110'
+    end
+
+    it "should have the expected encoding" do
+      @code.encoding.must_equal '11010011100101100111001000101100011100010110100011011101100011101011'
+    end
+
+    it "should have the expected checksum encoding" do
+      @code.checksum_encoding.must_equal '10001101110'
+    end
+
+  end
+
+  describe "Function characters" do
+
+    it "should retain the special symbols in the data accessor" do
+      Code128A.new(binary_encode("\301ABC\301DEF")).data.must_equal binary_encode("\301ABC\301DEF")
+      Code128B.new(binary_encode("\301ABC\302DEF")).data.must_equal binary_encode("\301ABC\302DEF")
+      Code128C.new(binary_encode("\301123456")).data.must_equal binary_encode("\301123456")
+      Code128C.new(binary_encode("12\30134\30156")).data.must_equal binary_encode("12\30134\30156")
+    end
+
+    it "should keep the special symbols as characters" do
+      Code128A.new(binary_encode("\301ABC\301DEF")).characters.must_equal binary_encode_array(%W(\301 A B C \301 D E F))
+      Code128B.new(binary_encode("\301ABC\302DEF")).characters.must_equal binary_encode_array(%W(\301 A B C \302 D E F))
+      Code128C.new(binary_encode("\301123456")).characters.must_equal binary_encode_array(%W(\301 12 34 56))
+      Code128C.new(binary_encode("12\30134\30156")).characters.must_equal binary_encode_array(%W(12 \301 34 \301 56))
+    end
+
+    it "should not allow FNC > 1 for Code C" do
+      lambda{ Code128C.new("12\302") }.must_raise ArgumentError
+      lambda{ Code128C.new("\30312") }.must_raise ArgumentError
+      lambda{ Code128C.new("12\304") }.must_raise ArgumentError
+    end
+
+    it "should be included in the encoding" do
+      a = Code128A.new(binary_encode("\301AB"))
+      a.data_encoding.must_equal '111101011101010001100010001011000'
+      a.encoding.must_equal '11010000100111101011101010001100010001011000101000011001100011101011'
+    end
+
+  end
+
+  describe "Code128 with type" do
+
+    #it "should raise an exception when not given a type" do
+    #  lambda{ Code128.new('abc') }.must_raise(ArgumentError)
+    #end
+
+    it "should raise an exception when given a non-existent type" do
+      lambda{ Code128.new('abc', 'F') }.must_raise(ArgumentError)
+    end
+
+    it "should not fail on frozen type" do
+      Code128.new('123456', 'C'.freeze) # not failing
+      Code128.new('123456', 'c'.freeze) # not failing even when upcasing
+    end
+
+    it "should give the right encoding for type A" do
+      code = Code128.new('ABC123', 'A')
+      code.encoding.must_equal '11010000100101000110001000101100010001000110100111001101100111001011001011100100100001101100011101011'
+    end
+
+    it "should give the right encoding for type B" do
+      code = Code128.new('abc123', 'B')
+      code.encoding.must_equal '11010010000100101100001001000011010000101100100111001101100111001011001011100110111011101100011101011'
+    end
+
+    it "should give the right encoding for type B" do
+      code = Code128.new('123456', 'C')
+      code.encoding.must_equal '11010011100101100111001000101100011100010110100011011101100011101011'
+    end
+
+  end
+
+
+
+  describe "Code128 automatic charset" do
+=begin
+	5.4.7.7. Use of Start, Code Set, and Shift Characters to Minimize Symbol Length (Informative)
+
+	The same data may be represented by different GS1-128 barcodes through the use of different combinations of Start, code set, and shift characters.
+
+	The following rules should normally be implemented in printer control software to minimise the number of symbol characters needed to represent a given data string (and, therefore, reduce the overall symbol length).
+
+	* Determine the Start Character:
+	  - If the data consists of two digits, use Start Character C.
+	  - If the data begins with four or more numeric data characters, use Start Character C.
+	  - If an ASCII symbology element (e.g., NUL) occurs in the data before any lowercase character, use Start Character A.
+	  - Otherwise, use Start Character B.
+	* If Start Character C is used and the data begins with an odd number of numeric data characters, insert a code set A or code set B character before the last digit, following rules 1c and 1d to determine between code sets A and B.
+	* If four or more numeric data characters occur together when in code sets A or B and:
+	  - If there is an even number of numeric data characters, then insert a code set C character before the first numeric digit to change to code set C.
+	  - If there is an odd number of numeric data characters, then insert a code set C character immediately after the first numeric digit to change to code set C.
+	* When in code set B and an ASCII symbology element occurs in the data:
+	  - If following that character, a lowercase character occurs in the data before the occurrence of another symbology element, then insert a shift character before the symbology element.
+	  - Otherwise, insert a code set A character before the symbology element to change to code set A.
+	* When in code set A and a lowercase character occurs in the data:
+	  - If following that character, a symbology element occurs in the data before the occurrence of another lowercase character, then insert a shift character before the lowercase character.
+	  - Otherwise, insert a code set B character before the lowercase character to change to code set B.
+		When in code set C and a non-numeric character occurs in the data, insert a code set A or code set B character before that character, and follow rules 1c and 1d to determine between code sets A and B.
+
+	Note: In these rules, the term “lowercase” is used for convenience to mean any code set B character with Code 128 Symbol character values 64 to 95 (ASCII values 96 to 127) (e.g., all lowercase alphanumeric characters plus `{|}~DEL). The term “symbology element” means any code set A character with Code 128 Symbol character values 64 to 95 (ASCII values 00 to 31).
+	Note 2: If the Function 1 Symbol Character (FNC1) occurs in the first position following the Start Character, or in an odd-numbered position in a numeric field, it should be treated as two digits for the purpose of determining the appropriate code set.
+=end
+    it "should minimize symbol length according to GS1-128 guidelines" do
+      # Determine the Start Character.
+      Code128.apply_shortest_encoding_for_data("#{FNC1}10").must_equal "#{CODEC}#{FNC1}10"
+      Code128.apply_shortest_encoding_for_data("#{FNC1}101234").must_equal "#{CODEC}#{FNC1}101234"
+      Code128.apply_shortest_encoding_for_data("10\001LOT").must_equal "#{CODEA}10\001LOT"
+      Code128.apply_shortest_encoding_for_data("lot1").must_equal "#{CODEB}lot1"
+
+      # Switching to codeset B from codeset C
+      Code128.apply_shortest_encoding_for_data("#{FNC1}101").must_equal "#{CODEC}#{FNC1}10#{CODEB}1"
+      # Switching to codeset A from codeset C
+      Code128.apply_shortest_encoding_for_data("#{FNC1}10\001a").must_equal "#{CODEC}#{FNC1}10#{CODEA}\001#{CODEB}a"
+
+      # Switching to codeset C from codeset A
+      Code128.apply_shortest_encoding_for_data("#{FNC1}10\001LOT1234").must_equal "#{CODEC}#{FNC1}10#{CODEA}\001LOT#{CODEC}1234"
+      Code128.apply_shortest_encoding_for_data("#{FNC1}10\001LOT12345").must_equal "#{CODEC}#{FNC1}10#{CODEA}\001LOT1#{CODEC}2345"
+
+      # Switching to codeset C from codeset B
+      Code128.apply_shortest_encoding_for_data("#{FNC1}10LOT1234").must_equal "#{CODEC}#{FNC1}10#{CODEB}LOT#{CODEC}1234"
+      Code128.apply_shortest_encoding_for_data("#{FNC1}10LOT12345").must_equal "#{CODEC}#{FNC1}10#{CODEB}LOT1#{CODEC}2345"
+
+      # Switching to codeset A from codeset B
+      Code128.apply_shortest_encoding_for_data("#{FNC1}10lot\001a").must_equal "#{CODEC}#{FNC1}10#{CODEB}lot#{SHIFT}\001a"
+      Code128.apply_shortest_encoding_for_data("#{FNC1}10lot\001\001").must_equal "#{CODEC}#{FNC1}10#{CODEB}lot#{CODEA}\001\001"
+
+      # Switching to codeset B from codeset A
+      Code128.apply_shortest_encoding_for_data("#{FNC1}10\001l\001").must_equal "#{CODEC}#{FNC1}10#{CODEA}\001#{SHIFT}l\001"
+      Code128.apply_shortest_encoding_for_data("#{FNC1}10\001ll").must_equal "#{CODEC}#{FNC1}10#{CODEA}\001#{CODEB}ll"
+
+      # testing "Note 2" from the GS1 specification
+      Code128.apply_shortest_encoding_for_data("#{FNC1}10LOT#{FNC1}0101").must_equal "#{CODEC}#{FNC1}10#{CODEB}LOT#{CODEC}#{FNC1}0101"
+      Code128.apply_shortest_encoding_for_data("#{FNC1}10LOT#{FNC1}01010").must_equal "#{CODEC}#{FNC1}10#{CODEB}LOT#{FNC1}0#{CODEC}1010"
+      Code128.apply_shortest_encoding_for_data("#{FNC1}10LOT01#{FNC1}0101").must_equal "#{CODEC}#{FNC1}10#{CODEB}LOT#{CODEC}01#{FNC1}0101"
+    end
+
+    it "should know how to extract CODEC segments properly from a data string" do
+      Code128.send(:extract_codec, "1234abcd5678\r\n\r\n").must_equal ["1234", "abcd", "5678", "\r\n\r\n"]
+      Code128.send(:extract_codec, "12345abc6").must_equal ["1234", "5abc6"]
+      Code128.send(:extract_codec, "abcdef").must_equal ["abcdef"]
+      Code128.send(:extract_codec, "123abcdef45678").must_equal ["123abcdef4", "5678"]
+      Code128.send(:extract_codec, "abcd12345").must_equal ["abcd1", "2345"]
+      Code128.send(:extract_codec, "abcd12345efg").must_equal ["abcd1", "2345", "efg"]
+      Code128.send(:extract_codec, "12345").must_equal ["1234", "5"]
+      Code128.send(:extract_codec, "12345abc").must_equal ["1234", "5abc"]
+      Code128.send(:extract_codec, "abcdef1234567").must_equal ["abcdef1", "234567"]
+    end
+
+    it "should know how to most efficiently apply different encodings to a data string" do
+      Code128.apply_shortest_encoding_for_data("123456").must_equal "#{CODEC}123456"
+      Code128.apply_shortest_encoding_for_data("abcdef").must_equal "#{CODEB}abcdef"
+      Code128.apply_shortest_encoding_for_data("ABCDEF").must_equal "#{CODEB}ABCDEF"
+      Code128.apply_shortest_encoding_for_data("\n\t\r").must_equal "#{CODEA}\n\t\r"
+      Code128.apply_shortest_encoding_for_data("123456abcdef").must_equal "#{CODEC}123456#{CODEB}abcdef"
+      Code128.apply_shortest_encoding_for_data("abcdef123456").must_equal "#{CODEB}abcdef#{CODEC}123456"
+      Code128.apply_shortest_encoding_for_data("1234567").must_equal "#{CODEC}123456#{CODEB}7"
+      Code128.apply_shortest_encoding_for_data("123b456").must_equal "#{CODEB}123b456"
+      Code128.apply_shortest_encoding_for_data("abc123def45678gh").must_equal "#{CODEB}abc123def4#{CODEC}5678#{CODEB}gh"
+      Code128.apply_shortest_encoding_for_data("12345AB\nEEasdgr12EE\r\n").must_equal "#{CODEC}1234#{CODEA}5AB\nEE#{CODEB}asdgr12EE#{CODEA}\r\n"
+      Code128.apply_shortest_encoding_for_data("123456QWERTY\r\n\tAAbbcc12XX34567").must_equal "#{CODEC}123456#{CODEA}QWERTY\r\n\tAA#{CODEB}bbcc12XX3#{CODEC}4567"
+
+      Code128.apply_shortest_encoding_for_data("ABCdef\rGHIjkl").must_equal "#{CODEB}ABCdef#{SHIFT}\rGHIjkl"
+      Code128.apply_shortest_encoding_for_data("ABC\rb\nDEF12gHI3456").must_equal "#{CODEA}ABC\r#{SHIFT}b\nDEF12#{CODEB}gHI#{CODEC}3456"
+      Code128.apply_shortest_encoding_for_data("ABCdef\rGHIjkl\tMNop\nqRs").must_equal "#{CODEB}ABCdef#{SHIFT}\rGHIjkl#{SHIFT}\tMNop#{SHIFT}\nqRs"
+    end
+
+    it "should apply automatic charset when no charset is given" do
+      b = Code128.new("123456QWERTY\r\n\tAAbbcc12XX34567")
+      b.type.must_equal 'C'
+      b.full_data_with_change_codes.must_equal "123456#{CODEA}QWERTY\r\n\tAA#{CODEB}bbcc12XX3#{CODEC}4567"
+    end
+
+  end
+
+
+
+  private
+
+  def binary_encode_array(datas)
+    datas.each { |data| binary_encode(data) }
+  end
+
+  def binary_encode(data)
+    ruby_19_or_greater? ? data.force_encoding('BINARY') : data
+  end
+
+end

data/test/code_25_iata_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+require 'barby/barcode/code_25_iata'
+
+class Code25IATATest < Barby::TestCase
+
+  before do
+    @data = '0123456789'
+    @code = Code25IATA.new(@data)
+  end
+
+  it "should have the expected start_encoding" do
+    @code.start_encoding.must_equal '1010'
+  end
+
+  it "should have the expected stop_encoding" do
+    @code.stop_encoding.must_equal '11101'
+  end
+
+end

data/test/code_25_interleaved_test.rb

@@ -0,0 +1,116 @@
+require 'test_helper'
+require 'barby/barcode/code_25_interleaved'
+
+class Code25InterleavedTest < Barby::TestCase
+
+  before do
+    @data = '12345670'
+    @code = Code25Interleaved.new(@data)
+  end
+
+  it "should have the expected digit_pairs" do
+    @code.digit_pairs.must_equal [[1,2],[3,4],[5,6],[7,0]]
+  end
+
+  it "should have the expected digit_encodings" do
+    @code.digit_encodings.must_equal %w(111010001010111000 111011101000101000 111010001110001010 101010001110001110)
+  end
+
+  it "should have the expected start_encoding" do
+    @code.start_encoding.must_equal '1010'
+  end
+
+  it "should have the expected stop_encoding" do
+    @code.stop_encoding.must_equal '11101'
+  end
+
+  it "should have the expected data_encoding" do
+    @code.data_encoding.must_equal "111010001010111000111011101000101000111010001110001010101010001110001110"
+  end
+
+  it "should have the expected encoding" do
+    @code.encoding.must_equal "101011101000101011100011101110100010100011101000111000101010101000111000111011101"
+  end
+
+  it "should be valid" do
+    assert @code.valid?
+  end
+
+  it "should return the expected encoding for parameters passed to encoding_for_interleaved" do
+    w, n = Code25Interleaved::WIDE, Code25Interleaved::NARROW
+    #                              1 2 1 2 1 2 1 2 1 2  digits 1 and 2
+    #                              B S B S B S B S B S  bars and spaces
+    @code.encoding_for_interleaved(w,n,n,w,n,n,n,n,w,w).must_equal '111010001010111000'
+    #                              3 4 3 4 3 4 3 4 3 4  digits 3 and 4
+    #                              B S B S B S B S B S  bars and spaces
+    @code.encoding_for_interleaved(w,n,w,n,n,w,n,n,n,w).must_equal '111011101000101000'
+  end
+
+  it "should return all characters in sequence for to_s" do
+    @code.to_s.must_equal @code.characters.join
+  end
+  
+  describe "with checksum" do
+
+    before do
+      @data = '1234567'
+      @code = Code25Interleaved.new(@data)
+      @code.include_checksum = true
+    end
+
+    it "should have the expected digit_pairs_with_checksum" do
+      @code.digit_pairs_with_checksum.must_equal [[1,2],[3,4],[5,6],[7,0]]
+    end
+
+    it "should have the expected digit_encodings_with_checksum" do
+      @code.digit_encodings_with_checksum.must_equal %w(111010001010111000 111011101000101000 111010001110001010 101010001110001110)
+    end
+
+    it "should have the expected data_encoding_with_checksum" do
+      @code.data_encoding_with_checksum.must_equal "111010001010111000111011101000101000111010001110001010101010001110001110"
+    end
+
+    it "should have the expected encoding" do
+      @code.encoding.must_equal "101011101000101011100011101110100010100011101000111000101010101000111000111011101"
+    end
+
+    it "should be valid" do
+      assert @code.valid?
+    end
+
+    it "should return all characters including checksum in sequence on to_s" do
+      @code.to_s.must_equal  @code.characters_with_checksum.join
+    end
+
+  end
+
+  describe "with invalid number of digits" do
+
+    before do
+      @data = '1234567'
+      @code = Code25Interleaved.new(@data)
+    end
+
+    it "should not be valid" do
+      refute @code.valid?
+    end
+
+    it "should raise ArgumentError on all encoding methods" do
+      lambda{ @code.encoding }.must_raise(ArgumentError)
+      lambda{ @code.data_encoding }.must_raise(ArgumentError)
+      lambda{ @code.digit_encodings }.must_raise(ArgumentError)
+    end
+
+    it "should not raise ArgumentError on encoding methods that include checksum" do
+      b = Code25Interleaved.new(@data)
+      b.include_checksum = true
+      b.encoding
+      @code.data_encoding_with_checksum
+      @code.digit_encodings_with_checksum
+    end
+
+  end
+
+end
+
+