barcode1dtools 0.9.2

data/test/test_barcode1di2of5.rb

@@ -0,0 +1,86 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+require 'test/unit'
+require 'barcode1dtools'
+
+class Barcode1DToolsInterleaved2of5Test < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  # Creates a random number from 1 to 10 digits long
+  def random_x_digit_number
+    (rand*10000000000).to_int
+  end
+
+  def test_checksum_generation
+    assert_equal 5, Barcode1DTools::Interleaved2of5.generate_check_digit_for(123456789)
+  end
+
+  def test_checksum_validation
+    assert Barcode1DTools::Interleaved2of5.validate_check_digit_for(1234567895)
+  end
+
+  def test_attr_readers
+    i2of5 = Barcode1DTools::Interleaved2of5.new(123456789, :checksum_included => false)
+    assert_equal 5, i2of5.check_digit
+    assert_equal 123456789, i2of5.value
+    assert_equal '1234567895', i2of5.encoded_string
+  end
+
+  def test_checksum_error
+    # proper checksum is 5
+    assert_raise(Barcode1DTools::ChecksumError) { Barcode1DTools::Interleaved2of5.new(1234567890, :checksum_included => true) }
+  end
+
+  def test_skip_checksum
+    i2of5 = Barcode1DTools::Interleaved2of5.new(1234567890, :skip_checksum => true)
+    assert_nil i2of5.check_digit
+    assert_equal 1234567890, i2of5.value
+    assert_equal '1234567890', i2of5.encoded_string
+  end
+
+  def test_add_leading_zero
+    i2of5 = Barcode1DTools::Interleaved2of5.new(123, :skip_checksum => true)
+    assert_equal '0123', i2of5.encoded_string
+    i2of5 = Barcode1DTools::Interleaved2of5.new(12)
+    assert_equal '0123', i2of5.encoded_string
+  end
+
+  def test_bad_character_errors
+    # Characters that cannot be encoded
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Interleaved2of5.new('thisisnotgood', :checksum_included => false) }
+  end
+
+  # Only need to test wn, as bars and rle are based on wn
+  def test_barcode_generation
+    i2of5 = Barcode1DTools::Interleaved2of5.new(602003, :skip_checksum => true)
+    assert_equal "nnnnnnwnwwnwnnnnwnnwnwwnnwnwwnwnnnwnn", i2of5.wn
+  end
+
+  def test_decode_error
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Interleaved2of5.decode('x') }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Interleaved2of5.decode('x'*60) }
+    # proper start & stop, but crap in middle
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Interleaved2of5.decode('nnnnwwwwnn') }
+    # wrong start/stop
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::Interleaved2of5.decode('nwwnwnwnwnwnwnw') }
+  end
+
+  def test_decoding
+    random_i2of5_num=random_x_digit_number
+    i2of5 = Barcode1DTools::Interleaved2of5.new(random_i2of5_num, :skip_checksum => true)
+    i2of52 = Barcode1DTools::Interleaved2of5.decode(i2of5.wn)
+    assert_equal i2of5.value, i2of52.value
+    # Should also work in reverse
+    i2of54 = Barcode1DTools::Interleaved2of5.decode(i2of5.wn.reverse)
+    assert_equal i2of5.value, i2of54.value
+  end
+end

data/test/test_barcode1dupca.rb

@@ -0,0 +1,102 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+require 'test/unit'
+require 'barcode1dtools'
+
+class Barcode1DToolsUPC_ATest < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  # Creates a random UPC-A sans checksum
+  def random_11_digit_number
+    (0..10).collect { |x| ((rand * 10).to_i % 10).to_s }.join
+  end
+
+  def test_checksum_generation
+    assert_equal 7, Barcode1DTools::UPC_A.generate_check_digit_for('07820601001')
+  end
+
+  def test_checksum_validation
+    assert Barcode1DTools::UPC_A.validate_check_digit_for('884088516338')
+  end
+
+  def test_attr_readers
+    upc_a = Barcode1DTools::UPC_A.new('88408851633', :checksum_included => false)
+    assert_equal 8, upc_a.check_digit
+    assert_equal '88408851633', upc_a.value
+    assert_equal '884088516338', upc_a.encoded_string
+    assert_equal '8', upc_a.number_system
+    assert_equal '84088', upc_a.manufacturers_code
+    assert_equal '51633', upc_a.product_code
+  end
+
+  def test_value_fixup
+    upc_a = Barcode1DTools::UPC_A.new('88408851633', :checksum_included => false)
+    assert_equal 8, upc_a.check_digit
+    assert_equal '88408851633', upc_a.value
+    assert_equal '884088516338', upc_a.encoded_string
+  end
+
+  def test_checksum_error
+    # proper checksum is 8
+    assert_raise(Barcode1DTools::ChecksumError) { Barcode1DTools::UPC_A.new('884088516331', :checksum_included => true) }
+  end
+
+  def test_value_length_errors
+    # One digit too short
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_A.new('0123456789', :checksum_included => false) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_A.new('01234567890', :checksum_included => true) }
+    # One digit too long
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_A.new('012345678901', :checksum_included => false) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_A.new('0123456789012', :checksum_included => true) }
+  end
+
+  def test_bad_character_errors
+    # Characters that cannot be encoded
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_A.new('thisisnotgood', :checksum_included => false) }
+  end
+
+  def test_width
+    upc_a = Barcode1DTools::UPC_A.new('041343005796', :checksum_included => true)
+    assert_equal 95, upc_a.width
+  end
+
+  def test_barcode_generation
+    upc_a = Barcode1DTools::UPC_A.new('012676510226', :checksum_included => true)
+    assert_equal "10100011010011001001001101011110111011010111101010100111011001101110010110110011011001010000101", upc_a.bars
+    assert_equal "11132112221212211141312111411111123122213211212221221114111", upc_a.rle
+  end
+
+  def test_wn_raises_error
+    upc_a = Barcode1DTools::UPC_A.new('012676510226', :checksum_included => true)
+    assert_raise(Barcode1DTools::NotImplementedError) { upc_a.wn }
+  end
+
+  def test_decode_error
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_A.decode('x') }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_A.decode('x'*60) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_A.decode('x'*96) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_A.decode('x'*94) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_A.decode('111000011111000011111') }
+  end
+
+  def test_decoding
+    random_ean_num=random_11_digit_number
+    ean = Barcode1DTools::UPC_A.new(random_ean_num)
+    ean2 = Barcode1DTools::UPC_A.decode(ean.bars)
+    assert_equal ean.value, ean2.value
+    ean3 = Barcode1DTools::UPC_A.decode(ean.rle)
+    assert_equal ean.value, ean3.value
+    # Should also work in reverse
+    ean4 = Barcode1DTools::UPC_A.decode(ean.bars.reverse)
+    assert_equal ean.value, ean4.value
+  end
+end

data/test/test_barcode1dupce.rb

@@ -0,0 +1,127 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+require 'test/unit'
+require 'barcode1dtools'
+
+class Barcode1DToolsUPC_ETest < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  # Creates a random UPC-E sans checksum and initial "0"
+  def random_upce_number(type = rand(4))
+    if type == 0
+      # manufacturer # is xx000, xx100, or xx200, with a 3-digit
+      # product number.  The manufacturer # is split between the
+      # first two digits and the final digit.
+      sprintf('%02d%03d%1d', rand(100), rand(1000), rand(3))
+    elsif type == 1
+      # manufacturer # is xx300, xx400, xx500, xx600, xx700, xx800,
+      # or xx900, with a 2-digit item number.  The final digit is 3.
+      sprintf('%02d%1d%02d3', rand(100), rand(7)+3, rand(100))
+    elsif type == 2
+      # manufacturer # is xxx10, xxx20, xxx30, xxx40, xxx50, xxx60,
+      # xxx70, xxx80, or xxx90, with a single-digit item number.
+      # The final digit is 4.
+      sprintf('%03d%1d%1d4', rand(1000), rand(9)+1, rand(10))
+    else
+      # manufacturer # is xxxx1, xxxx2, xxxx3, xxxx4, xxxx5, xxxx6,
+      # xxxx7, xxxx8, or xxxx9, and the single-digit item number
+      # is between 5 and 9.
+      sprintf('%04d%1d%1d', rand(10000), rand(9)+1, rand(5)+5)
+    end
+  end
+
+  def test_checksum_generation
+    assert_equal 3, Barcode1DTools::UPC_E.generate_check_digit_for('333333')
+  end
+
+  def test_checksum_validation
+    assert Barcode1DTools::UPC_E.validate_check_digit_for('03333333')
+  end
+
+  def test_upc_a_upc_e_conversion
+    assert_equal '03330000033', Barcode1DTools::UPC_E.upce_value_to_upca_value('0333333')
+    upce_value_0 = '0' + random_upce_number(0)
+    assert_equal upce_value_0, Barcode1DTools::UPC_E.upca_value_to_upce_value(Barcode1DTools::UPC_E.upce_value_to_upca_value(upce_value_0))
+    upce_value_1 = '0' + random_upce_number(1)
+    assert_equal upce_value_1, Barcode1DTools::UPC_E.upca_value_to_upce_value(Barcode1DTools::UPC_E.upce_value_to_upca_value(upce_value_1))
+    upce_value_2 = '0' + random_upce_number(2)
+    assert_equal upce_value_2, Barcode1DTools::UPC_E.upca_value_to_upce_value(Barcode1DTools::UPC_E.upce_value_to_upca_value(upce_value_2))
+    upce_value_3 = '0' + random_upce_number(3)
+    assert_equal upce_value_3, Barcode1DTools::UPC_E.upca_value_to_upce_value(Barcode1DTools::UPC_E.upce_value_to_upca_value(upce_value_3))
+  end
+
+  def test_attr_readers
+    upc_e = Barcode1DTools::UPC_E.new('333333', :checksum_included => false)
+    assert_equal 3, upc_e.check_digit
+    assert_equal '333333', upc_e.value
+    assert_equal '3333333', upc_e.encoded_string
+    assert_equal '0', upc_e.number_system
+    assert_equal '33300', upc_e.manufacturers_code
+    assert_equal '00033', upc_e.product_code
+    assert_equal '03330000033', upc_e.upca_value
+  end
+
+  def test_checksum_error
+    # proper checksum is 3
+    assert_raise(Barcode1DTools::ChecksumError) { Barcode1DTools::UPC_E.new('3333331', :checksum_included => true) }
+  end
+
+  def test_value_length_errors
+    # One digit too short
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_E.new('33333', :checksum_included => false) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_E.new('333333', :checksum_included => true) }
+    # One digit too long
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_E.new('03333333', :checksum_included => false) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_E.new('033333332', :checksum_included => true) }
+  end
+
+  def test_bad_character_errors
+    # Characters that cannot be encoded
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_E.new('thisisnotgood', :checksum_included => false) }
+  end
+
+  def test_width
+    upc_e = Barcode1DTools::UPC_E.new(random_upce_number)
+    assert_equal 51, upc_e.width
+  end
+
+  def test_barcode_generation
+    upc_e = Barcode1DTools::UPC_E.new('01245714', :checksum_included => true)
+    assert_equal "101011001100100110011101011100101110110011001010101", upc_e.bars
+    assert_equal "111122221222311132113122221111111", upc_e.rle
+  end
+
+  def test_wn_raises_error
+    upc_e = Barcode1DTools::UPC_E.new(random_upce_number)
+    assert_raise(Barcode1DTools::NotImplementedError) { upc_e.wn }
+  end
+
+  def test_decode_error
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_E.decode('x') }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_E.decode('x'*60) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_E.decode('x'*96) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_E.decode('x'*94) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_E.decode('111000011111000011111') }
+  end
+
+  def test_decoding
+    random_upce_num=random_upce_number
+    upce = Barcode1DTools::UPC_E.new('0'+random_upce_num)
+    upce2 = Barcode1DTools::UPC_E.decode(upce.bars)
+    assert_equal upce.value, upce2.value
+    upce3 = Barcode1DTools::UPC_E.decode(upce.rle)
+    assert_equal upce.value, upce3.value
+    # Should also work in reverse
+    upce4 = Barcode1DTools::UPC_E.decode(upce.bars.reverse)
+    assert_equal upce.value, upce4.value
+  end
+end

data/test/test_barcode1dupcsupp2.rb

@@ -0,0 +1,89 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+require 'test/unit'
+require 'barcode1dtools'
+
+class Barcode1DToolsUPC_Supp2Test < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  # Creates a random 2-digit number
+  def random_2_digit_number
+    rand(100)
+  end
+
+  def test_checksum_generation
+    assert_equal 3, Barcode1DTools::UPC_Supplemental_2.generate_check_digit_for('23')
+  end
+
+  def test_checksum_validation
+    assert Barcode1DTools::UPC_Supplemental_2.validate_check_digit_for('233')
+  end
+
+  def test_attr_readers
+    upc_supp_2 = Barcode1DTools::UPC_Supplemental_2.new('23', :checksum_included => false)
+    assert_equal 3, upc_supp_2.check_digit
+    assert_equal 23, upc_supp_2.value
+    assert_equal '233', upc_supp_2.encoded_string
+  end
+
+  def test_checksum_error
+    # proper checksum is 3
+    assert_raise(Barcode1DTools::ChecksumError) { Barcode1DTools::UPC_Supplemental_2.new('231', :checksum_included => true) }
+  end
+
+  def test_value_length_errors
+    # One digit too long
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_2.new('233', :checksum_included => false) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_2.new('2333', :checksum_included => true) }
+  end
+
+  def test_bad_character_errors
+    # Characters that cannot be encoded
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_2.new('thisisnotgood', :checksum_included => false) }
+  end
+
+  def test_width
+    upc_supp_2 = Barcode1DTools::UPC_Supplemental_2.new(random_2_digit_number)
+    assert_equal 20, upc_supp_2.width
+  end
+
+  def test_barcode_generation
+    upc_supp_2 = Barcode1DTools::UPC_Supplemental_2.new('233', :checksum_included => true)
+    assert_equal "10110011011010100001", upc_supp_2.bars
+    assert_equal "1122212111141", upc_supp_2.rle
+  end
+
+  def test_wn_raises_error
+    upc_supp_2 = Barcode1DTools::UPC_Supplemental_2.new(random_2_digit_number)
+    assert_raise(Barcode1DTools::NotImplementedError) { upc_supp_2.wn }
+  end
+
+  def test_decode_error
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_2.decode('x') }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_2.decode('x'*60) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_2.decode('x'*96) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_2.decode('x'*94) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_2.decode('11100001111100001111') }
+  end
+
+  def test_decoding
+    random_upcsupp2_num=random_2_digit_number
+    upcsupp2 = Barcode1DTools::UPC_Supplemental_2.new(random_upcsupp2_num)
+    upcsupp22 = Barcode1DTools::UPC_Supplemental_2.decode(upcsupp2.bars)
+    assert_equal upcsupp2.value, upcsupp22.value
+    upcsupp23 = Barcode1DTools::UPC_Supplemental_2.decode(upcsupp2.rle)
+    assert_equal upcsupp2.value, upcsupp23.value
+    # Should also work in reverse
+    upcsupp24 = Barcode1DTools::UPC_Supplemental_2.decode(upcsupp2.bars.reverse)
+    assert_equal upcsupp2.value, upcsupp24.value
+  end
+end

data/test/test_barcode1dupcsupp5.rb

@@ -0,0 +1,94 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+require 'test/unit'
+require 'barcode1dtools'
+
+class Barcode1DToolsUPC_Supp5Test < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  # Creates a random 2-digit number
+  def random_5_digit_number
+    sprintf('%05d',rand(100000))
+  end
+
+  def test_checksum_generation
+    assert_equal 7, Barcode1DTools::UPC_Supplemental_5.generate_check_digit_for('53999')
+  end
+
+  def test_checksum_validation
+    assert Barcode1DTools::UPC_Supplemental_5.validate_check_digit_for('539997')
+  end
+
+  def test_attr_readers
+    upc_supp_5 = Barcode1DTools::UPC_Supplemental_5.new('53999', :checksum_included => false)
+    assert_equal 7, upc_supp_5.check_digit
+    assert_equal '53999', upc_supp_5.value
+    assert_equal '539997', upc_supp_5.encoded_string
+    assert_equal '5', upc_supp_5.currency_code
+    assert_equal '3999', upc_supp_5.price
+  end
+
+  def test_checksum_error
+    # proper checksum is 7
+    assert_raise(Barcode1DTools::ChecksumError) { Barcode1DTools::UPC_Supplemental_5.new('539990', :checksum_included => true) }
+  end
+
+  def test_value_length_errors
+    # One digit too short
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_5.new('5399', :checksum_included => false) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_5.new('53999', :checksum_included => true) }
+    # One digit too long
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_5.new('539999', :checksum_included => false) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_5.new('5399979', :checksum_included => true) }
+  end
+
+  def test_bad_character_errors
+    # Characters that cannot be encoded
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_5.new('thisisnotgood', :checksum_included => false) }
+  end
+
+  def test_width
+    upc_supp_5 = Barcode1DTools::UPC_Supplemental_5.new(random_5_digit_number)
+    assert_equal 47, upc_supp_5.width
+  end
+
+  def test_barcode_generation
+    upc_supp_5 = Barcode1DTools::UPC_Supplemental_5.new('539997', :checksum_included => true)
+    assert_equal "10110110001010100001010001011010010111010001011", upc_supp_5.bars
+    assert_equal "1121231111141113112112113113112", upc_supp_5.rle
+  end
+
+  def test_wn_raises_error
+    upc_supp_5 = Barcode1DTools::UPC_Supplemental_5.new(random_5_digit_number)
+    assert_raise(Barcode1DTools::NotImplementedError) { upc_supp_5.wn }
+  end
+
+  def test_decode_error
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_5.decode('x') }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_5.decode('x'*60) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_5.decode('x'*96) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_5.decode('x'*94) }
+    assert_raise(Barcode1DTools::UnencodableCharactersError) { Barcode1DTools::UPC_Supplemental_5.decode('1110000111110000111110010101001') }
+  end
+
+  def test_decoding
+    random_upcsupp5_num=random_5_digit_number
+    upcsupp5 = Barcode1DTools::UPC_Supplemental_5.new(random_upcsupp5_num)
+    upcsupp52 = Barcode1DTools::UPC_Supplemental_5.decode(upcsupp5.bars)
+    assert_equal upcsupp5.value, upcsupp52.value
+    upcsupp53 = Barcode1DTools::UPC_Supplemental_5.decode(upcsupp5.rle)
+    assert_equal upcsupp5.value, upcsupp53.value
+    # Should also work in reverse
+    upcsupp54 = Barcode1DTools::UPC_Supplemental_5.decode(upcsupp5.bars.reverse)
+    assert_equal upcsupp5.value, upcsupp54.value
+  end
+end