snmp 1.0.3 → 1.0.4

data/lib/snmp/version.rb

@@ -0,0 +1,3 @@
+module SNMP
+  VERSION = "1.0.4"
+end

data/test/test_ber.rb

@@ -4,237 +4,236 @@ require 'snmp/ber'
 
 class ASN1_Test < Test::Unit::TestCase
 
-    include SNMP::BER
-
-    def test_decode_tlv_empty
-        tag, value, data = decode_tlv("\001\000")
-        assert_equal(1, tag)
-        assert_equal("", value)
-        assert_equal("", data)
-
-        tag, value, data = decode_tlv("\001\000\111")
-        assert_equal(1, tag)
-        assert_equal("", value)
-        assert_equal("\111", data)
-    end
-    
-    # Decode TLV data with the short-format length field.
-    def test_decode_tlv_short
-        tag, value, data = decode_tlv("\001\002\023\044")
-        assert_equal(1, tag)
-        assert_equal("\023\044", value)
-        assert_equal("", data)
-    end
-    
-    # Extra bytes of data are returned.
-    def test_decode_tlv_short_extra
-        tag, value, data = decode_tlv("\001\002\023\044\000")
-        assert_equal(1, tag)
-        assert_equal("\023\044", value)
-        assert_equal("\000", data)
-    end
-
-    # Decode TLV data with long-format length field
-    def test_decode_tlv_long
-        long_data = ""; 128.times { |i| long_data << i.chr }
-        tag, value, data = decode_tlv("\001\201\200" + long_data)
-        assert_equal(1, tag)
-        assert_equal(long_data, value)
-        assert_equal("", data)
-    end
-        
-    # Long format with extra bytes - use four bytes for length
-    def test_decode_tlv_long_extra
-        long_data = ""; 129.times { |i| long_data << i.chr }
-        tag, value, data = decode_tlv("\001\204\000\000\000\201" + long_data + "\123\123\123")
-        assert_equal(1, tag)
-        assert_equal(long_data, value)
-        assert_equal("\123\123\123", data)
-    end
-
-    # Check invalid length - ASN.1 says that first length octet can't be 255.
-    def test_bad_length
-        assert_raise(InvalidLength) {
-            decode_tlv("\001\377\001")
-        }
-    end
-    
-    # Check if input data is too short
-    def test_out_of_data
-        assert_raise(OutOfData) {
-            decode_tlv("\001\001")
-        }
-        assert_raise(OutOfData) {
-            decode_tlv("\001")
-        }
-        assert_raise(OutOfData) {
-            decode_tlv("")
-        }
-    end
-    
-    # Decode single-octet ASN.1 integer.
-    # Number is negative (2's complement) if high order bit is 1.
-    def test_decode_integer_octet
-        i, data = decode_integer("\002\001\042")
-        assert_equal(34, i)
-        assert_equal("", data)
-        i, data = decode_integer("\002\001\377")
-        assert_equal(-1, i)
-        assert_equal("", data)
-    end
-
-    # Decode multi-octet ASN.1 integer.
-    def test_decode_integer
-        i, data = decode_integer("\002\004\001\002\003\004")
-        assert_equal(16909060, i)
-        assert_equal("", data)
-
-        i, data = decode_integer("\002\004\377\377\377\376")
-        assert_equal(-2, i)
-        assert_equal("", data)
-
-        i, data = decode_integer("\002\003\000\377\376")
-        assert_equal(65534, i)
-        assert_equal("", data)
-        
-        i, data = decode_integer("\002\002\000\377")
-        assert_equal(255, i)
-        assert_equal("", data)
-
-        assert_raise(InvalidTag) {
-            decode_integer("\001\004\001\002\003\004")
-        }
-    end
-
-    def test_decode_timeticks
-        i, data = decode_timeticks("\103\004\001\002\003\004")
-        assert_equal(16909060, i)
-        assert_equal("", data)
-        
-        assert_raise(InvalidTag) {
-            decode_timeticks("\002\004\001\002\003\004")
-        }
-    end
-    
-    # Decode ASN.1 octet string
-    def test_decode_octet_string
-        s, data = decode_octet_string("\004\202\000\005hello")
-        assert_equal("hello",s)
-        assert_raise(InvalidTag) {
-            decode_octet_string("\005\202\000\005hello")
-        }
-    end
-    
-    def test_decode_ip_address
-        ip, data = decode_ip_address("@\004\001\002\003\004")
-        assert_equal(ip, "\001\002\003\004")
-        assert_raise(InvalidTag) {
-            decode_ip_address("\004\004\001\002\003\004")
-        }
-        assert_raise(InvalidLength) {
-            decode_ip_address("@\005\001\002\003\004\005")
-        }
-    end
-    
-    # Decode ASN.1 sequence
-    def test_decode_sequence
-        seq, data = decode_sequence("\060\003\002\001\077")
-        assert_equal("\002\001\077", seq)
-        assert_equal("", data)
-        
-        seq, data = decode_sequence("\060\003\002\001\077\002\001\001")
-        assert_equal("\002\001\077", seq)
-        assert_equal("\002\001\001", data)
-        
-        assert_raise(InvalidTag) {
-            decode_sequence("\061\003\002\001\077")
-        }
-    end
-    
-    def test_decode_object_id
-        # Handle an empty object identifier because net-snmp does it and
-        # they probably had a good reason.
-        object_id, remainder = decode_object_id("\006\000")
-        assert_equal([], object_id)
-        assert_equal("", remainder)
-        
-        object_id, remainder = decode_object_id("\006\001+")
-        assert_equal([1,3], object_id);
-        assert_equal("", remainder)
-
-        object_id, remainder = decode_object_id("\006\002+\006")
-        assert_equal([1,3,6], object_id);
-        assert_equal("", remainder)
-
-        object_id, remainder = decode_object_id("\006\003+\202\001")
-        assert_equal([1,3,257], object_id);
-        assert_equal("", remainder)
-
-        object_id, remainder = decode_object_id("\006\003S\202\001")
-        assert_equal([2,3,257], object_id);
-        assert_equal("", remainder)
-
-        object_id, remainder = decode_object_id("\006\001\000")
-        assert_equal([0,0], object_id);
-        assert_equal("", remainder)
-
-        assert_raise(InvalidTag) do
-            decode_object_id("\007\001+")
-        end
-    end
-    
-    def test_encode_length
-        assert_equal("\000", encode_length(0))
-        assert_equal("\001", encode_length(1))
-        assert_equal("\177", encode_length(127))
-        assert_equal("\201\200", encode_length(128))
-        assert_equal("\202\002\001", encode_length(513))
-        assert_raise(InvalidLength) { encode_length(-1) }
-    end
-    
-    def test_encode_integer
-        assert_equal("\002\001\000", encode_integer(0))
-        assert_equal("\002\001\001", encode_integer(1))
-        assert_equal("\002\001\177", encode_integer(127))
-        assert_equal("\002\002\000\200", encode_integer(128))
-        assert_equal("\002\002\000\377", encode_integer(255))
-        assert_equal("\002\002\001\000", encode_integer(256))
-        
-        assert_equal("\002\001\377", encode_integer(-1))
-        assert_equal("\002\001\200", encode_integer(-128))
-        assert_equal("\002\002\377\177", encode_integer(-129))
-    end
-    
-    def test_encode_octet_string
-        assert_equal("\004\015Dave was here", encode_octet_string("Dave was here"))
-        assert_equal("\004\000", encode_octet_string(""))
-    end
-    
-    def test_encode_sequence
-        assert_equal("0\015Dave was here", encode_sequence("Dave was here"))
-        assert_equal("0\000", encode_sequence(""))
-    end
-    
-    def test_encode_null
-        assert_equal("\005\000", encode_null)
-    end
-    
-    def test_encode_exception
-        assert_equal("\200\000", encode_exception(0x80))
-    end
-    
-    def test_encode_object_id
-        assert_equal("\006\001" << 80.chr, encode_object_id([2]))
-        assert_equal("\006\001\000", encode_object_id([0,0]))
-        assert_equal("\006\001+", encode_object_id([1,3]))
-        assert_equal("\006\002+\006", encode_object_id([1,3,6]))
-        assert_equal("\006\003+\202\001", encode_object_id([1,3,257]))
-        assert_equal("\006\003" << 82.chr << "\202\001", encode_object_id([2,2,257]))
-        assert_raise(InvalidObjectId) { encode_object_id([3,2,257]) }
-        assert_raise(InvalidObjectId) { encode_object_id([]) }
-        
-        assert_equal("\006\a+\203\377\177\203\377\177",
-            encode_object_id(SNMP::ObjectId.new("1.3.65535.65535")))
-    end
+  include SNMP::BER
+
+  def test_decode_tlv_empty
+    tag, value, data = decode_tlv("\001\000")
+    assert_equal(1, tag)
+    assert_equal("", value)
+    assert_equal("", data)
+
+    tag, value, data = decode_tlv("\001\000\111")
+    assert_equal(1, tag)
+    assert_equal("", value)
+    assert_equal("\111", data)
+  end
+
+  # Decode TLV data with the short-format length field.
+  def test_decode_tlv_short
+    tag, value, data = decode_tlv("\001\002\023\044")
+    assert_equal(1, tag)
+    assert_equal("\023\044", value)
+    assert_equal("", data)
+  end
+
+  # Extra bytes of data are returned.
+  def test_decode_tlv_short_extra
+    tag, value, data = decode_tlv("\001\002\023\044\000")
+    assert_equal(1, tag)
+    assert_equal("\023\044", value)
+    assert_equal("\000", data)
+  end
+
+  # Decode TLV data with long-format length field
+  def test_decode_tlv_long
+    long_data = ""; 128.times { |i| long_data << i.chr }
+    tag, value, data = decode_tlv("\001\201\200" + long_data)
+    assert_equal(1, tag)
+    assert_equal(long_data, value)
+    assert_equal("", data)
+  end
+
+  # Long format with extra bytes - use four bytes for length
+  def test_decode_tlv_long_extra
+    long_data = ""; 129.times { |i| long_data << i.chr }
+    tag, value, data = decode_tlv("\001\204\000\000\000\201" + long_data + "\123\123\123")
+    assert_equal(1, tag)
+    assert_equal(long_data, value)
+    assert_equal("\123\123\123", data)
+  end
+
+  # Check invalid length - ASN.1 says that first length octet can't be 255.
+  def test_bad_length
+    assert_raise(InvalidLength) {
+      decode_tlv("\001\377\001")
+    }
+  end
+
+  # Check if input data is too short
+  def test_out_of_data
+    assert_raise(OutOfData) {
+      decode_tlv("\001\001")
+    }
+    assert_raise(OutOfData) {
+      decode_tlv("\001")
+    }
+    assert_raise(OutOfData) {
+      decode_tlv("")
+    }
+  end
+
+  # Decode single-octet ASN.1 integer.
+  # Number is negative (2's complement) if high order bit is 1.
+  def test_decode_integer_octet
+    i, data = decode_integer("\002\001\042")
+    assert_equal(34, i)
+    assert_equal("", data)
+    i, data = decode_integer("\002\001\377")
+    assert_equal(-1, i)
+    assert_equal("", data)
+  end
+
+  # Decode multi-octet ASN.1 integer.
+  def test_decode_integer
+    i, data = decode_integer("\002\004\001\002\003\004")
+    assert_equal(16909060, i)
+    assert_equal("", data)
+
+    i, data = decode_integer("\002\004\377\377\377\376")
+    assert_equal(-2, i)
+    assert_equal("", data)
+
+    i, data = decode_integer("\002\003\000\377\376")
+    assert_equal(65534, i)
+    assert_equal("", data)
+
+    i, data = decode_integer("\002\002\000\377")
+    assert_equal(255, i)
+    assert_equal("", data)
+
+    assert_raise(InvalidTag) {
+      decode_integer("\001\004\001\002\003\004")
+    }
+  end
+
+  def test_decode_timeticks
+    i, data = decode_timeticks("\103\004\001\002\003\004")
+    assert_equal(16909060, i)
+    assert_equal("", data)
+
+    assert_raise(InvalidTag) {
+      decode_timeticks("\002\004\001\002\003\004")
+    }
+  end
+
+  # Decode ASN.1 octet string
+  def test_decode_octet_string
+    s, data = decode_octet_string("\004\202\000\005hello")
+    assert_equal("hello",s)
+    assert_raise(InvalidTag) {
+      decode_octet_string("\005\202\000\005hello")
+    }
+  end
+
+  def test_decode_ip_address
+    ip, data = decode_ip_address("@\004\001\002\003\004")
+    assert_equal(ip, "\001\002\003\004")
+    assert_raise(InvalidTag) {
+      decode_ip_address("\004\004\001\002\003\004")
+    }
+    assert_raise(InvalidLength) {
+      decode_ip_address("@\005\001\002\003\004\005")
+    }
+  end
+
+  # Decode ASN.1 sequence
+  def test_decode_sequence
+    seq, data = decode_sequence("\060\003\002\001\077")
+    assert_equal("\002\001\077", seq)
+    assert_equal("", data)
+
+    seq, data = decode_sequence("\060\003\002\001\077\002\001\001")
+    assert_equal("\002\001\077", seq)
+    assert_equal("\002\001\001", data)
+
+    assert_raise(InvalidTag) {
+      decode_sequence("\061\003\002\001\077")
+    }
+  end
+
+  def test_decode_object_id
+    # Handle an empty object identifier because net-snmp does it and
+    # they probably had a good reason.
+    object_id, remainder = decode_object_id("\006\000")
+    assert_equal([], object_id)
+    assert_equal("", remainder)
+
+    object_id, remainder = decode_object_id("\006\001+")
+    assert_equal([1,3], object_id);
+    assert_equal("", remainder)
+
+    object_id, remainder = decode_object_id("\006\002+\006")
+    assert_equal([1,3,6], object_id);
+    assert_equal("", remainder)
+
+    object_id, remainder = decode_object_id("\006\003+\202\001")
+    assert_equal([1,3,257], object_id);
+    assert_equal("", remainder)
+
+    object_id, remainder = decode_object_id("\006\003S\202\001")
+    assert_equal([2,3,257], object_id);
+    assert_equal("", remainder)
+
+    object_id, remainder = decode_object_id("\006\001\000")
+    assert_equal([0,0], object_id);
+    assert_equal("", remainder)
+
+    assert_raise(InvalidTag) do
+      decode_object_id("\007\001+")
+    end
+  end
+
+  def test_encode_length
+    assert_equal("\000", encode_length(0))
+    assert_equal("\001", encode_length(1))
+    assert_equal("\177", encode_length(127))
+    assert_equal("\201\200", encode_length(128))
+    assert_equal("\202\002\001", encode_length(513))
+    assert_raise(InvalidLength) { encode_length(-1) }
+  end
+
+  def test_encode_integer
+    assert_equal("\002\001\000", encode_integer(0))
+    assert_equal("\002\001\001", encode_integer(1))
+    assert_equal("\002\001\177", encode_integer(127))
+    assert_equal("\002\002\000\200", encode_integer(128))
+    assert_equal("\002\002\000\377", encode_integer(255))
+    assert_equal("\002\002\001\000", encode_integer(256))
+
+    assert_equal("\002\001\377", encode_integer(-1))
+    assert_equal("\002\001\200", encode_integer(-128))
+    assert_equal("\002\002\377\177", encode_integer(-129))
+  end
+
+  def test_encode_octet_string
+    assert_equal("\004\015Dave was here", encode_octet_string("Dave was here"))
+    assert_equal("\004\000", encode_octet_string(""))
+  end
+
+  def test_encode_sequence
+    assert_equal("0\015Dave was here", encode_sequence("Dave was here"))
+    assert_equal("0\000", encode_sequence(""))
+  end
+
+  def test_encode_null
+    assert_equal("\005\000", encode_null)
+  end
+
+  def test_encode_exception
+    assert_equal("\200\000", encode_exception(0x80))
+  end
+
+  def test_encode_object_id
+    assert_equal("\006\001" << 80.chr, encode_object_id([2]))
+    assert_equal("\006\001\000", encode_object_id([0,0]))
+    assert_equal("\006\001+", encode_object_id([1,3]))
+    assert_equal("\006\002+\006", encode_object_id([1,3,6]))
+    assert_equal("\006\003+\202\001", encode_object_id([1,3,257]))
+    assert_equal("\006\003" << 82.chr << "\202\001", encode_object_id([2,2,257]))
+    assert_raise(InvalidObjectId) { encode_object_id([3,2,257]) }
+    assert_raise(InvalidObjectId) { encode_object_id([]) }
+
+    assert_equal("\006\a+\203\377\177\203\377\177",
+                 encode_object_id(SNMP::ObjectId.new("1.3.65535.65535")))
+  end
 end
-