bencode 0.4.0 → 0.5.0

data/lib/bencode.rb

@@ -5,8 +5,8 @@
 #
 # == Synopsis
 #
-# Bencoding (pronounced <i>bee-encode</i>) is a simple protocol, consisting of
-# only 4 value types.
+# Bencoding (pronounced <i>bee-encode</i>) is a simple protocol, 
+# consisting of only 4 value types.
 #
 # === Integers
 #
@@ -21,8 +21,8 @@
 # === Strings
 #   
 # Strings are sequences of zero or more bytes. They are encoded as 
-# <i>&lt;length&gt;:&lt;contents&gt;</i>, where _length_ is the length of _contents_. _length_
-# must be non-negative.
+# <i>&lt;length&gt;:&lt;contents&gt;</i>, where _length_ is the 
+# length of _contents_. _length_ must be non-negative.
 #
 #   "".bencode     #=> "0:"
 #   "foo".bencode  #=> "3:foo"
@@ -36,9 +36,9 @@
 #
 # === Dictionaries
 #
-# Dictionaries are encoded as _d_ followed by a sequence of key-value pairs, followed by _e_. 
-# Each value must be immediately preceded by a key. Keys must be strings, and must appear in 
-# lexicographical order.
+# Dictionaries are encoded as _d_ followed by a sequence of key-value 
+# pairs, followed by _e_. Each value must be immediately preceded by 
+# a key. Keys must be strings, and must appear in lexicographical order.
 #
 #   {"foo" => 3, "bar" => 1, "baz" => 2}.bencode  
 #     #=> "d3:bari1e3:bazi2e3:fooi3ee"
@@ -62,179 +62,17 @@
 # version.
 # 
 # Bencode is distributed in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-#
-
-class Object
-  #
-  # Raises an exception. Subclasses of Object must themselves
-  # define meaningful #bencode methods.
-  def bencode
-    raise BencodeError, "object cannot be bencoded"
-  end
-end
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more 
+# details.
 
-class Integer
-  #
-  # Bencodes the Integer object. Bencoded integers are represented
-  # as +ixe+, where +x+ is the integer with an optional
-  # hyphen prepended, indicating negativity.
-  #
-  #   42.bencode   #=> "i42e"
-  #   -7.bencode   #=> "i-7e"
-  def bencode
-    "i#{self}e"
-  end
-end
-
-class String
-  #
-  # Bencodes the String object. Bencoded strings are represented
-  # as <code>x</code>:<code>y</code>, where +y+ is the string and +x+ is the length of the
-  # string.
-  #   
-  #   "foo".bencode   #=> "3:foo"
-  #   "".bencode      #=> "0:"
-  #
-  def bencode
-    "#{length}:#{self}"
-  end
 
-  #
-  # Bdecodes the String object and returns the data serialized
-  # through bencoding.
-  #
-  #   "li1ei2ei3ee".bdecode   #=> [1, 2, 3]
-  #
-  def bdecode
-    Bencode.load(self)
-  end
+prefix = File.dirname(__FILE__)
 
-  #
-  # Tests whether the String object is a valid bencoded string.
-  def bencoded?
-    bdecode
-  rescue BdecodeError
-    false
-  else
-    true
-  end
+%w[object integer string array hash].each do |type|
+  require prefix + '/bencode/encode/' + type
 end
 
-class Array
-  #
-  # Bencodes the Array object. Bencoded arrays are represented as
-  # +lxe+, where +x+ is zero or more bencoded objects.
-  #
-  #   [1, "foo"].bencode   #=> "li1e3:fooe"
-  #
-  def bencode
-    "l#{map{|obj| obj.bencode }.join('')}e"
-  rescue BencodeError
-    raise BencodeError, "list items must be bencodable"
-  end
-end
-
-class Hash
-  #
-  # Bencodes the Hash object. Bencoded hashes are represented as
-  # +dxe+, where +x+ is zero or a power of two bencoded objects. 
-  # each key is immediately followed by its associated value.
-  # All keys must be strings. The keys of the bencoded hash will
-  # be in lexicographical order.
-  def bencode
-    pairs = sort.map{|key, val| [key.to_str.bencode, val.bencode] }
-    "d#{pairs.join('')}e"
-  rescue NoMethodError => error
-    if error.name == :to_str
-      raise BencodeError, "dictionary keys must be strings"
-    else
-      raise
-    end
-  end
-end
-
-class IO
-  def self.bdecode(filename)
-    open(filename, 'r').bdecode
-  end
-
-  def self.bencode(filename)
-    open(filename, 'r').bencode
-  end
-
-  def bdecode
-    read.chomp.bdecode
-  end
-
-  def bencode
-    read.chomp.bencode
-  end
-end
-
-class BencodeError < StandardError; end
-
-class BdecodeError < StandardError; end
-
-module Bencode
-  class << self
-    # Bencodes +obj+
-    def dump(obj)
-      obj.bencode
-    end
-
-    # Bdecodes +str+
-    def load(str)
-      require 'strscan'
-
-      scanner = StringScanner.new(str)
-      obj = parse(scanner)
-      raise BdecodeError unless scanner.eos?
-      return obj
-    end
-
-    # Bdecodes the file located at +path+
-    def load_file(path)
-      load(File.open(path).read)
-    end
-
-    def parse(scanner) # :nodoc:
-      case token = scanner.scan(/[ild]|\d+:|\s/)
-      when nil
-        raise BdecodeError
-      when "i"
-        number = scanner.scan(/0|(?:-?[1-9][0-9]*)/)
-        raise BdecodeError unless number and scanner.scan(/e/)
-        return number.to_i
-      when "l"
-        ary = []
-        until scanner.peek(1) == "e"
-          ary.push(parse(scanner))
-        end
-        scanner.pos += 1
-        return ary
-      when "d"
-        hsh = {}
-        until scanner.peek(1) == "e"
-          key, value = parse(scanner), parse(scanner)
-          raise BdecodeError, "key must be a string" unless key.is_a? String
-          hsh.store(key, value)
-        end
-        scanner.pos += 1
-        return hsh
-      when /\d+:/
-        length = token.chop.to_i
-        str = scanner.peek(length)
-        scanner.pos += length
-        return str
-      when /\s/
-        nil
-      else
-        raise BdecodeError
-      end
-    end
-
-    private :parse
-  end
+%w[decode io encode_error decode_error].each do |file|
+  require prefix + '/bencode/' + file
 end

data/lib/bencode/decode.rb

@@ -0,0 +1,82 @@
+
+module BEncode
+  class << self
+    # BEncodes +obj+
+    def dump(obj)
+      obj.bencode
+    end
+
+    # Bdecodes +str+
+    def load(str)
+      require 'strscan'
+
+      scanner = StringScanner.new(str)
+      obj = parse(scanner)
+      raise BEncode::DecodeError unless scanner.eos?
+      return obj
+    end
+
+    # Bdecodes the file located at +path+
+    def load_file(path)
+      load(File.open(path).read)
+    end
+
+    def parse(scanner) # :nodoc:
+      case token = scanner.scan(/[ild]|\d+:|\s/)
+      when nil
+        raise BEncode::DecodeError
+      when "i"
+        number = scanner.scan(/0|(?:-?[1-9][0-9]*)/)
+        raise BEncode::DecodeError unless number and scanner.scan(/e/)
+        return number.to_i
+      when "l"
+        ary = []
+        until scanner.peek(1) == "e"
+          ary.push(parse(scanner))
+        end
+        scanner.pos += 1
+        return ary
+      when "d"
+        hsh = {}
+        until scanner.peek(1) == "e"
+          key, value = parse(scanner), parse(scanner)
+
+          unless key.is_a? String
+            raise BEncode::DecodeError, "key must be a string"
+          end
+
+          hsh.store(key, value)
+        end
+        scanner.pos += 1
+        return hsh
+      when /\d+:/
+        length = token.chop.to_i
+        str = scanner.peek(length)
+
+        begin
+          scanner.pos += length
+        rescue RangeError
+          raise BEncode::DecodeError, "invalid string length"
+        end
+
+        return str
+      else
+        raise BEncode::DecodeError
+      end
+    end
+
+    private :parse
+  end
+end
+
+class String
+  #
+  # Bdecodes the String object and returns the data serialized
+  # through bencoding.
+  #
+  #   "li1ei2ei3ee".bdecode   #=> [1, 2, 3]
+  #
+  def bdecode
+    BEncode.load(self)
+  end
+end

data/lib/bencode/decode_error.rb

@@ -0,0 +1,4 @@
+
+unless BEncode.const_defined? :DecodeError
+  BEncode::DecodeError = Class.new(StandardError)
+end

data/lib/bencode/encode/array.rb

@@ -0,0 +1,19 @@
+
+class Array
+  #
+  # Bencodes the Array object. Bencoded arrays are represented as
+  # +lxe+, where +x+ is zero or more bencoded objects.
+  #
+  #   [1, "foo"].bencode   #=> "li1e3:fooe"
+  #
+  def bencode
+    begin
+      "l#{map{|obj| obj.bencode }.join('')}e"
+    rescue BEncode::EncodeError
+      raise BEncode::EncodeError, "array items must be bencodable"
+    # TODO: This is probably a bad idea...
+    rescue SystemStackError
+      raise BEncode::EncodeError, "cannot encode recursive array"
+    end
+  end
+end

data/lib/bencode/encode/hash.rb

@@ -0,0 +1,19 @@
+
+class Hash
+  #
+  # Bencodes the Hash object. Bencoded hashes are represented as
+  # +dxe+, where +x+ is zero or a power of two bencoded objects. 
+  # each key is immediately followed by its associated value.
+  # All keys must be strings. The keys of the bencoded hash will
+  # be in lexicographical order.
+  def bencode
+    pairs = sort.map{|key, val| [key.to_str.bencode, val.bencode] }
+    "d#{pairs.join('')}e"
+  rescue NoMethodError => error
+    if error.name == :to_str
+      raise BEncode::EncodeError, "dictionary keys must be strings"
+    else
+      raise
+    end
+  end
+end

data/lib/bencode/encode/integer.rb

@@ -0,0 +1,13 @@
+
+class Integer
+  #
+  # Bencodes the Integer object. Bencoded integers are represented
+  # as +ixe+, where +x+ is the integer with an optional
+  # hyphen prepended, indicating negativity.
+  #
+  #   42.bencode   #=> "i42e"
+  #   -7.bencode   #=> "i-7e"
+  def bencode
+    "i#{self}e"
+  end
+end

data/lib/bencode/encode/object.rb

@@ -0,0 +1,9 @@
+
+class Object
+  #
+  # Raises an exception. Subclasses of Object must themselves
+  # define meaningful #bencode methods.
+  def bencode
+    raise BEncode::EncodeError, "cannot bencode #{self.class}"
+  end
+end

data/lib/bencode/encode/string.rb

@@ -0,0 +1,14 @@
+
+class String
+  #
+  # Bencodes the String object. Bencoded strings are represented
+  # as <code>x</code>:<code>y</code>, where +y+ is the string and +x+ 
+  # is the length of the string.
+  #   
+  #   "foo".bencode   #=> "3:foo"
+  #   "".bencode      #=> "0:"
+  #
+  def bencode
+    "#{length}:#{self}"
+  end
+end

data/lib/bencode/encode_error.rb

@@ -0,0 +1,4 @@
+
+unless BEncode.const_defined? :EncodeError
+  BEncode::EncodeError = Class.new(StandardError)
+end

data/lib/bencode/io.rb

@@ -0,0 +1,18 @@
+
+class IO
+  def self.bdecode(filename)
+    open(filename, 'r').bdecode
+  end
+
+  def self.bencode(filename)
+    open(filename, 'r').bencode
+  end
+
+  def bdecode
+    read.chomp.bdecode
+  end
+
+  def bencode
+    read.chomp.bencode
+  end
+end

data/test/decode/test_dictionary.rb

@@ -0,0 +1,18 @@
+
+require 'test/unit'
+require File.dirname(__FILE__) + "/../../lib/bencode.rb"
+
+class BdecodeDictionaryTest < Test::Unit::TestCase
+  def test_empty
+    assert_equal Hash.new, "de".bdecode
+  end
+
+  def test_single_pair
+    assert_equal({"a" => 42}, 'd1:ai42ee'.bdecode)
+  end
+
+  def test_multi_pair
+    hsh = {"a" => "monkey", "h" => "elephant", "z" => "zebra"}
+    assert_equal hsh, "d1:a6:monkey1:h8:elephant1:z5:zebrae".bdecode
+  end
+end

data/test/decode/test_integer.rb

@@ -0,0 +1,32 @@
+
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/bencode.rb"
+
+class BdecodeIntegerTest < Test::Unit::TestCase
+  def test_zero
+    assert_equal 0, 'i0e'.bdecode
+  end
+  
+  def test_single_digit
+    (1..9).each do |digit|
+      assert_equal digit, "i#{digit}e".bdecode
+    end
+  end
+
+  def test_multi_digit
+    (1..10).each do |digit|
+      assert_equal digit * 10, "i#{digit * 10}e".bdecode
+    end
+  end
+
+  def test_negative
+    (-9..-1).each do |digit|
+      assert_equal digit, "i#{digit}e".bdecode
+    end
+  end
+
+  def test_invalid
+    assert_raise(BEncode::DecodeError){ 'i01e'.bdecode }
+    assert_raise(BEncode::DecodeError){ 'i-0e'.bdecode }
+  end
+end

data/test/decode/test_invalid.rb

@@ -0,0 +1,17 @@
+
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/bencode.rb"
+
+class BdecodeInvalidTest < Test::Unit::TestCase
+  errors = {:empty_string => '',
+            :space_string => ' ',
+            :unencoded_string => 'foobar',
+            :multiple_top_items => 'i1ei2e',
+            :string_length => '4:foo'}
+
+  errors.each do |error, data|
+    define_method("test_#{error}") do
+      assert_raise(BEncode::DecodeError){ data.bdecode }
+    end
+  end
+end

data/test/decode/test_list.rb

@@ -0,0 +1,24 @@
+
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/bencode.rb"
+
+class BdecodeListTest < Test::Unit::TestCase
+  def test_empty
+    assert_equal [], 'le'.bdecode
+  end
+
+  def test_string_list
+    assert_equal %w[foo], 'l3:fooe'.bdecode
+    assert_equal %w[a b c], 'l1:a1:b1:ce'.bdecode
+  end
+
+  def test_integer_list
+    assert_equal [0], 'li0ee'.bdecode
+    assert_equal [1, 2, 3], 'li1ei2ei3ee'.bdecode
+  end
+
+  def test_list_list
+    assert_equal [[]], 'llee'.bdecode
+    assert_equal [[], [], []], 'llelelee'.bdecode
+  end
+end

data/test/decode/test_string.rb

@@ -0,0 +1,23 @@
+
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/bencode.rb"
+
+class BdecodeStringTest < Test::Unit::TestCase
+  def test_empty
+    assert_equal '', '0:'.bdecode
+  end
+
+  def test_single_line
+    assert_equal 'foo', '3:foo'.bdecode
+  end
+
+  def test_multi_line
+    assert_equal "a\nb", "3:a\nb".bdecode
+  end
+
+  def test_whitespace
+    [" ", "\t", "\n", "\r"].each do |char|
+      assert_equal char, "1:#{char}".bdecode
+    end
+  end
+end

data/test/encode/test_array.rb

@@ -0,0 +1,55 @@
+
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/bencode.rb"
+
+class BencodeListTest < Test::Unit::TestCase
+  # Asserts that an empty array is encoded correctly.
+  def test_empty
+    assert_equal 'le', [].bencode
+  end
+
+  # Asserts that arrays of integers are encoded correctly.
+  def test_integer_list
+    assert_equal 'li1ee', [1].bencode
+    assert_equal 'li1ei2ei3ei4ee', [1, 2, 3, 4].bencode
+  end
+
+  # Asserts that trying to encode a list containing a
+  # floating point number raises a +BEncode::EncodeError+.
+  def test_float_list
+    assert_raise BEncode::EncodeError do
+      [13.37].bencode
+    end
+  end
+
+  def test_string_list
+    assert_equal 'l3:fooe', %w[foo].bencode
+    assert_equal 'l1:a1:b1:ce', %w[a b c].bencode
+  end
+
+  def test_list_list
+    assert_equal 'llee', [[]].bencode
+    assert_equal 'llleee', [[[]]].bencode
+    assert_equal 'llelelee', [[], [], []].bencode
+  end
+
+  # Asserts that a recursive array is not bencoded.
+  # TODO: Uses waaaaay too much time. What to do?
+  def _test_recursive_list
+    assert_raise BEncode::EncodeError do
+      list = []
+      list << list
+      list.bencode
+    end
+
+    assert_raise BEncode::EncodeError do
+      list = [[]]
+      list.first << list
+      list.bencode
+    end
+  end
+
+  def test_dict_list
+    assert_equal 'ldee', [{}].bencode
+  end
+end

data/test/encode/test_float.rb

@@ -0,0 +1,11 @@
+
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/bencode.rb"
+
+class BencodeFloatTest < Test::Unit::TestCase
+  def test_illegal_number
+    assert_raise BEncode::EncodeError do
+      13.37.bencode
+    end
+  end
+end

data/test/encode/test_hash.rb

@@ -0,0 +1,27 @@
+
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/bencode.rb"
+
+class BencodeDictionaryTest < Test::Unit::TestCase
+  def test_empty
+    assert_equal 'de', {}.bencode
+  end
+
+  def test_integer_hash
+    assert_equal 'd1:ai1ee', {'a' => 1}.bencode
+    assert_equal 'd1:ai1e1:bi2e1:ci3ee', 
+                 {'a' => 1, 'b' => 2, 'c' => 3}.bencode
+  end
+
+  def test_illegal_keys
+    assert_raise BEncode::EncodeError do
+      {1 => 'foo'}.bencode
+    end
+  end
+
+  # Thank you, Julien
+  def test_key_order
+    assert_equal 'd1:ai1e2:bbi3e1:ci2ee', 
+                 {'a' => 1, 'c' => 2, 'bb' => 3}.bencode
+  end
+end

data/test/encode/test_integer.rb

@@ -0,0 +1,27 @@
+
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/bencode.rb"
+
+class BencodeIntegerTest < Test::Unit::TestCase
+  def test_zero
+    assert_equal 'i0e', 0.bencode
+  end
+
+  def test_single_digit
+    (1..9).each do |digit|
+      assert_equal "i#{digit}e", digit.bencode
+    end
+  end
+
+  def test_multi_digit
+    (1..10).each do |digit|
+      assert_equal "i#{digit * 10}e", (digit * 10).bencode
+    end
+  end
+
+  def test_negative
+    (-9..-1).each do |digit|
+      assert_equal "i#{digit}e", digit.bencode
+    end
+  end
+end

data/test/encode/test_string.rb

@@ -0,0 +1,32 @@
+
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/bencode.rb"
+
+class BencodeStringTest < Test::Unit::TestCase
+  def test_empty
+    assert_equal '0:', ''.bencode
+  end
+
+  def test_single_char
+    ('a'..'z').each do |char|
+      assert_equal '1:' + char, char.bencode
+    end
+  end
+
+  def test_single_line
+    assert_equal '2:ab', 'ab'.bencode
+    assert_equal '3:abc', 'abc'.bencode
+    assert_equal '4:abcd', 'abcd'.bencode
+  end
+
+  def test_whitespace
+    [" ", "\t", "\n", "\r"].each do |char|
+      assert_equal '1:' + char, char.bencode
+      assert_equal '2:' + char * 2, (char * 2).bencode
+    end
+  end
+
+  def test_multi_line
+    assert_equal "3:a\nb", "a\nb".bencode
+  end
+end

data/test/suite.rb

@@ -0,0 +1,5 @@
+
+prefix = File.dirname(__FILE__)
+
+require prefix + '/test_encode'
+require prefix + '/test_decode'

data/test/test_decode.rb

@@ -0,0 +1,4 @@
+
+%w[string integer list dictionary invalid].each do |str|
+  require File.dirname(__FILE__) + "/decode/test_#{str}"
+end

data/test/test_encode.rb

@@ -0,0 +1,4 @@
+
+%w[string integer float array hash].each do |str|
+  require File.dirname(__FILE__) + "/encode/test_#{str}"
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: bencode
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
-date: 2006-12-26 00:00:00 +01:00
+  version: 0.5.0
+date: 2007-02-07 00:00:00 +01:00
 summary: A Ruby implementation of the Bencode encoding used by BitTorrent
 require_paths: 
 - lib
@@ -30,10 +30,42 @@ authors:
 - Daniel Schierbeck
 files: 
 - lib/bencode.rb
+- lib/bencode/io.rb
+- lib/bencode/encode_error.rb
+- lib/bencode/decode.rb
+- lib/bencode/decode_error.rb
+- lib/bencode/encode/object.rb
+- lib/bencode/encode/integer.rb
+- lib/bencode/encode/hash.rb
+- lib/bencode/encode/array.rb
+- lib/bencode/encode/string.rb
+- test/test_decode.rb
+- test/test_encode.rb
+- test/suite.rb
+- test/decode/test_invalid.rb
+- test/decode/test_dictionary.rb
+- test/decode/test_integer.rb
+- test/decode/test_string.rb
+- test/decode/test_list.rb
+- test/encode/test_float.rb
+- test/encode/test_hash.rb
+- test/encode/test_integer.rb
+- test/encode/test_string.rb
+- test/encode/test_array.rb
 test_files: 
-- test/test_suite.rb
-- test/tc_bencode.rb
-- test/tc_bdecode.rb
+- test/test_decode.rb
+- test/test_encode.rb
+- test/suite.rb
+- test/decode/test_invalid.rb
+- test/decode/test_dictionary.rb
+- test/decode/test_integer.rb
+- test/decode/test_string.rb
+- test/decode/test_list.rb
+- test/encode/test_float.rb
+- test/encode/test_hash.rb
+- test/encode/test_integer.rb
+- test/encode/test_string.rb
+- test/encode/test_array.rb
 rdoc_options: []
 
 extra_rdoc_files: []

data/test/tc_bdecode.rb

@@ -1,55 +0,0 @@
-
-require 'test/unit'
-require "#{File.dirname(__FILE__)}/../lib/bencode"
-
-class BdecodeTest < Test::Unit::TestCase
-  def test_string
-    assert_equal "", "0:".bdecode
-    assert_equal "foo", "3:foo".bdecode
-    assert_equal "foo bar", "7:foo bar".bdecode
-  end
-
-  def test_integer
-    assert_equal 0, "i0e".bdecode
-    assert_equal 42, "i42e".bdecode
-    assert_equal -7, "i-7e".bdecode
-  end
-
-  def test_invalid_integer
-    assert_raise BdecodeError do
-      "i01e".bdecode
-    end
-    assert_raise BdecodeError do
-      "i-01e".bdecode
-    end
-  end
-
-  def test_array
-    assert_equal [], "le".bdecode
-    assert_equal ["foo"], "l3:fooe".bdecode
-    assert_equal [1, 2, 3], "li1ei2ei3ee".bdecode
-  end
-
-  def test_hash
-    assert_equal Hash.new, "de".bdecode
-
-    hsh = {"a" => "monkey", "h" => "elephant", "z" => "zebra"}
-    assert_equal hsh, "d1:a6:monkey1:h8:elephant1:z5:zebrae".bdecode
-  end
-
-  def test_invalid
-    assert_raises BdecodeError do
-      "foobar".bdecode
-      "i1ei2e".bdecode
-      "4:foo".bdecode
-      "2:bar".bdecode
-    end
-  end
-
-  def test_valid
-    assert  "3:foo".bencoded?
-    assert !"3:foo3:bar".bencoded?
-    assert  "i42e".bencoded?
-    assert !"i42ei101e".bencoded?
-  end
-end

data/test/tc_bencode.rb

@@ -1,57 +0,0 @@
-
-require 'test/unit'
-require "#{File.dirname(__FILE__)}/../lib/bencode"
-
-class BencodeTest < Test::Unit::TestCase
-  def test_string
-    assert_equal "3:foo", "foo".bencode
-    assert_equal "0:", "".bencode
-  end
-
-  def test_tab_string
-    assert_equal "1:\t", "\t".bencode
-    assert_equal "2:\t\t", "\t\t".bencode
-  end
-
-  def test_multiline_string
-    assert_equal "1:\n", "\n".bencode
-    assert_equal "2:\n\n", "\n\n".bencode
-  end
-
-  def test_integer
-    assert_equal "i0e", 0.bencode
-    assert_equal "i42e", 42.bencode
-    assert_equal "i-3e", -3.bencode
-  end
-
-  def test_float
-    assert_raise BencodeError do
-      42.4.bencode
-    end
-  end
-
-  def test_array
-    assert_equal "le", [].bencode
-    assert_equal "li1ei2ei3ee", [1, 2, 3].bencode
-  end
-
-  def test_hash
-    assert_equal "de", {}.bencode
-    assert_equal "d1:a3:foo1:g3:bar1:z3:baze", 
-      {"a" => "foo", "g" => "bar", "z" => "baz"}.bencode
-  end
-
-  def test_illegal_hash_keys
-    assert_raise BencodeError do
-      {1 => 'foo'}.bencode
-    end
-    assert_raise BencodeError do
-      {1 => 'foo', 2 => 'bar'}.bencode
-    end
-  end
-
-  def test_hash_julien
-    assert_equal "d1:ai1e2:bbi1e1:ci1ee",
-      {'a' => 1, 'c' => 1, 'bb' => 1}.bencode
-  end
-end

data/test/test_suite.rb

@@ -1,3 +0,0 @@
-
-require 'tc_bencode'
-require 'tc_bdecode'