erlang_rb 1.3.2 → 1.3.3

data/README.markdown

@@ -5,3 +5,4 @@ Provides all encoding and decoding for the Erlang Binary Term Format
 (as defined at [http://erlang.org/doc/apps/erts/erl_ext_dist.html](http://erlang.org/doc/apps/erts/erl_ext_dist.html))
 in a single Ruby module.
 
+Available as a [Ruby gem at `https://rubygems.org/gems/erlang_rb`](https://rubygems.org/gems/erlang_rb).

data/lib/erlang.rb

@@ -38,48 +38,28 @@
 # DAMAGE.
 #
 
-module Erlang
+require 'zlib'
 
-    class OtpErlangList
-        def initialize(value)
-            @value = value
-        end
-        def to_s
-            arity = @value.length
-            if arity == 0
-                return TAG_NIL_EXT.chr
-            else
-                arity_packed = [arity].pack('N')
-                list_packed = @value.map{ |element|
-                    term_to_binary_(element)
-                }.join
-                return "#{TAG_LIST_EXT.chr}#{arity_packed}#{list_packed}#{TAG_NIL_EXT.chr}"
-            end
-        end
-        def hash
-            return to_s.hash
-        end
-        def ==(other)
-            return to_s == other.to_s
-        end
-        alias eql? ==
-    end
+module Erlang
 
     class OtpErlangAtom
         def initialize(value)
             @value = value
         end
-        def to_s
+        attr_reader :value
+        def binary
             if @value.kind_of?(Integer)
                 return "#{TAG_ATOM_CACHE_REF.chr}#{@value.chr}"
             elsif @value.kind_of?(String)
                 size = @value.bytesize
                 if @value.encoding.name == 'UTF-8'
                     if size < 256
-                        return "#{TAG_SMALL_ATOM_UTF8_EXT.chr}#{size.chr}#{@value}"
+                        return "#{TAG_SMALL_ATOM_UTF8_EXT.chr}#{size.chr}" \
+                               "#{@value}"
                     else
                         size_packed = [size].pack('n')
-                        return "#{TAG_ATOM_UTF8_EXT.chr}#{size_packed}#{@value}"
+                        return "#{TAG_ATOM_UTF8_EXT.chr}#{size_packed}" \
+                               "#{@value}"
                     end
                 else
                     if size < 256
@@ -93,34 +73,90 @@ module Erlang
                 raise OutputException, 'unknown atom type', caller
             end
         end
+        def to_s
+            return "#{self.class.name}('#{@value.to_s}')"
+        end
         def hash
-            return to_s.hash
+            return binary.hash
         end
         def ==(other)
-            return to_s == other.to_s
+            return binary == other.binary
         end
         alias eql? ==
     end
     
+    class OtpErlangList
+        def initialize(value, improper = false)
+            @value = value
+            @improper = improper
+        end
+        attr_reader :value
+        attr_reader :improper
+        def binary
+            if @value.kind_of?(Array)
+                length = @value.length
+                if length == 0
+                    return TAG_NIL_EXT.chr
+                elsif @improper
+                    length_packed = [length - 1].pack('N')
+                    list_packed = @value.map{ |element|
+                        Erlang::term_to_binary_(element)
+                    }.join
+                    return "#{TAG_LIST_EXT.chr}#{length_packed}#{list_packed}"
+                else
+                    length_packed = [length].pack('N')
+                    list_packed = @value.map{ |element|
+                        Erlang::term_to_binary_(element)
+                    }.join
+                    return "#{TAG_LIST_EXT.chr}#{length_packed}" \
+                           "#{list_packed}#{TAG_NIL_EXT.chr}"
+                end
+            else
+                raise OutputException, 'unknown list type', caller
+            end
+        end
+        def to_s
+            return "#{self.class.name}" \
+                   "(#{@value.to_s},improper=#{@improper.to_s})"
+        end
+        def hash
+            return binary.hash
+        end
+        def ==(other)
+            return binary == other.binary
+        end
+        alias eql? ==
+    end
+
     class OtpErlangBinary
         def initialize(value, bits = 8)
             @value = value
             @bits = bits # bits in last byte
         end
-        def to_s
-            size = @value.bytesize
-            size_packed = [size].pack('N')
-            if @bits != 8
-                return "#{TAG_BIT_BINARY_EXT.chr}#{size_packed}#{@bits.chr}#{@value}"
+        attr_reader :value
+        attr_reader :bits
+        def binary
+            if @value.kind_of?(String)
+                size = @value.bytesize
+                size_packed = [size].pack('N')
+                if @bits != 8
+                    return "#{TAG_BIT_BINARY_EXT.chr}#{size_packed}" \
+                           "#{@bits.chr}#{@value}"
+                else
+                    return "#{TAG_BINARY_EXT.chr}#{size_packed}#{@value}"
+                end
             else
-                return "#{TAG_BINARY_EXT.chr}#{size_packed}#{@value}"
+                raise OutputException, 'unknown binary type', caller
             end
         end
+        def to_s
+            return "#{self.class.name}('#{@value.to_s}',bits=#{@bits.to_s})"
+        end
         def hash
-            return to_s.hash
+            return binary.hash
         end
         def ==(other)
-            return to_s == other.to_s
+            return binary == other.binary
         end
         alias eql? ==
     end
@@ -130,14 +166,19 @@ module Erlang
             @tag = tag
             @value = value
         end
-        def to_s
+        attr_reader :tag
+        attr_reader :value
+        def binary
             return "#{@tag.chr}#{@value}"
         end
+        def to_s
+            return "#{self.class.name}('#{@tag.to_s}','#{@value.to_s}')"
+        end
         def hash
-            return to_s.hash
+            return binary.hash
         end
         def ==(other)
-            return to_s == other.to_s
+            return binary == other.binary
         end
         alias eql? ==
     end
@@ -148,20 +189,29 @@ module Erlang
             @id = id
             @creation = creation
         end
-        def to_s
+        attr_reader :node
+        attr_reader :id
+        attr_reader :creation
+        def binary
             size = @id.bytesize / 4
             if size > 1
                 size_packed = [size].pack('n')
-                return "#{TAG_NEW_REFERENCE_EXT.chr}#{size_packed}#{@node.to_s}#{@creation}#{@id}"
+                return "#{TAG_NEW_REFERENCE_EXT.chr}#{size_packed}" \
+                       "#{@node.binary}#{@creation}#{@id}"
             else
-                return "#{TAG_REFERENCE_EXT.chr}#{@node.to_s}#{@id}#{@creation}"
+                return "#{TAG_REFERENCE_EXT.chr}" \
+                       "#{@node.binary}#{@id}#{@creation}"
             end
         end
+        def to_s
+            return "#{self.class.name}" \
+                   "('#{@node.to_s}','#{@id.to_s}','#{@creation.to_s}')"
+        end
         def hash
-            return to_s.hash
+            return binary.hash
         end
         def ==(other)
-            return to_s == other.to_s
+            return binary == other.binary
         end
         alias eql? ==
     end
@@ -172,14 +222,21 @@ module Erlang
             @id = id
             @creation = creation
         end
+        attr_reader :node
+        attr_reader :id
+        attr_reader :creation
+        def binary
+            return "#{TAG_PORT_EXT.chr}#{@node.binary}#{@id}#{@creation}"
+        end
         def to_s
-            return "#{TAG_PORT_EXT.chr}#{@node.to_s}#{@id}#{@creation}"
+            return "#{self.class.name}" \
+                   "('#{@node.to_s}','#{@id.to_s}','#{@creation.to_s}')"
         end
         def hash
-            return to_s.hash
+            return binary.hash
         end
         def ==(other)
-            return to_s == other.to_s
+            return binary == other.binary
         end
         alias eql? ==
     end
@@ -191,39 +248,75 @@ module Erlang
             @serial = serial
             @creation = creation
         end
+        attr_reader :node
+        attr_reader :id
+        attr_reader :serial
+        attr_reader :creation
+        def binary
+            return "#{TAG_PID_EXT.chr}" \
+                   "#{@node.binary}#{@id}#{@serial}#{@creation}"
+        end
         def to_s
-            return "#{TAG_PID_EXT.chr}#{@node.to_s}#{@id}#{@serial}#{@creation}"
+            return "#{self.class.name}" \
+                   "('#{@node.to_s}','#{@id.to_s}','#{@serial.to_s}'," \
+                    "'#{@creation.to_s}')"
         end
         def hash
-            return to_s.hash
+            return binary.hash
         end
         def ==(other)
-            return to_s == other.to_s
+            return binary == other.binary
         end
         alias eql? ==
     end
     
-    def binary_to_term(data)
+    def self.binary_to_term(data)
+        size = data.bytesize
+        if size <= 1
+            raise ParseException, 'null input', caller
+        end
         if data[0].ord != TAG_VERSION
             raise ParseException, 'invalid version', caller
         end
-        result = binary_to_term_(1, data)
-        if result[0] != data.bytesize
-            raise ParseException, 'unparsed data', caller
+        begin
+            result = binary_to_term_(1, data)
+            if result[0] != size
+                raise ParseException, 'unparsed data', caller
+            end
+            return result[1]
+        rescue NoMethodError => e
+            raise ParseException, 'missing data', e.backtrace
+        rescue TypeError => e
+            raise ParseException, 'missing data', e.backtrace
+        rescue ArgumentError => e
+            raise ParseException, 'missing data', e.backtrace
         end
-        return result[1]
     end
     
-    def term_to_binary(term)
-        term_packed = term_to_binary_(term)
-        return "#{TAG_VERSION.chr}#{term_packed}"
+    def self.term_to_binary(term, compressed = false)
+        data_uncompressed = term_to_binary_(term)
+        if compressed == false
+            return "#{TAG_VERSION.chr}#{data_uncompressed}"
+        else
+            if compressed == true
+                compressed = 6
+            end
+            if compressed < 0 or compressed > 9
+                raise InputException, 'compressed in [0..9]', caller
+            end
+            data_compressed = Zlib::Deflate.deflate(data_uncompressed,
+                                                    compressed)
+            size_uncompressed_packed = [data_uncompressed.bytesize].pack('N')
+            return "#{TAG_VERSION.chr}#{TAG_COMPRESSED_ZLIB.chr}" \
+                   "#{size_uncompressed_packed}#{data_compressed}"
+        end
     end
     
     private
     
     # binary_to_term
     
-    def binary_to_term_(i, data)
+    def self.binary_to_term_(i, data)
         tag = data[i].ord
         i += 1
         if tag == TAG_NEW_FLOAT_EXT
@@ -237,13 +330,10 @@ module Erlang
         elsif tag == TAG_ATOM_CACHE_REF
             return [i + 1, OtpErlangAtom.new(ord(data[i,1]))]
         elsif tag == TAG_SMALL_INTEGER_EXT
-            return [i + 1, ord(data[i])]
+            return [i + 1, data[i].ord]
         elsif tag == TAG_INTEGER_EXT
-            value = data[i,4].unpack('N')[0]
-            if value & 0x80000000
-                value = -1 * (value & 0x7fffffff)
-            end
-            return [i + 4, Fixnum.induced_from(value)]
+            value = data[i,4].unpack('i>')[0]
+            return [i + 4, value]
         elsif tag == TAG_FLOAT_EXT
             value = data[i,31].partition(0.chr)[0].to_f
             return [i + 31, value]
@@ -252,7 +342,7 @@ module Erlang
             i += 2
             atom_name = data[i,j].force_encoding('ISO-8859-1')
             if atom_name.valid_encoding?
-                return [i + j, OtpErlangAtom.new(atom_name)]
+                return [i + j, atom_name.to_sym]
             else
                 raise ParseException, 'invalid atom_name latin1', caller
             end
@@ -302,10 +392,13 @@ module Erlang
             i = result[0]; tmp = result[1]
             result = binary_to_term_(i, data)
             i = result[0]; tail = result[1]
-            if tail.iskind?(OtpErlangList) == false
-                tmp.append(tail)
+            if tail.kind_of?(OtpErlangList) == false or tail.value != []
+                tmp.push(tail)
+                tmp = OtpErlangList.new(tmp, improper=true)
+            else
+                tmp = OtpErlangList.new(tmp)
             end
-            return [i, OtpErlangList.new(tmp)]
+            return [i, tmp]
         elsif tag == TAG_BINARY_EXT
             j = data[i,4].unpack('N')[0]
             i += 4
@@ -319,15 +412,15 @@ module Erlang
                 i += 4
             end
             sign = data[i].ord
-            i += 1
             bignum = 0
             (0...j).each do |bignum_index|
-                digit = data[i...(j - bignum_index)].ord
+                digit = data[i + j - bignum_index].ord
                 bignum = bignum * 256 + digit
             end
-            if sign
+            if sign == 1
                 bignum *= -1
             end
+            i += 1
             return [i + j, bignum]
         elsif tag == TAG_NEW_FUN_EXT
             size = data[i,4].unpack('N')[0]
@@ -359,7 +452,14 @@ module Erlang
             i += 1
             atom_name = data[i,j].force_encoding('ISO-8859-1')
             if atom_name.valid_encoding?
-                return [i + j, OtpErlangAtom.new(atom_name)]
+                if atom_name == 'true'
+                    tmp = true
+                elsif atom_name == 'false'
+                    tmp = false
+                else
+                    tmp = atom_name.to_sym
+                end
+                return [i + j, tmp]
             else
                 raise ParseException, 'invalid atom_name latin1', caller
             end
@@ -408,22 +508,40 @@ module Erlang
             else
                 raise ParseException, 'invalid atom_name unicode', caller
             end
+        elsif tag == TAG_COMPRESSED_ZLIB
+            size_uncompressed = data[i,4].unpack('N')[0]
+            if size_uncompressed == 0
+                raise ParseException, 'compressed data null', caller
+            end
+            i += 4
+            data_compressed = data[i..-1]
+            j = data_compressed.bytesize
+            data_uncompressed = Zlib::Inflate.inflate(data_compressed)
+            if size_uncompressed != data_uncompressed.bytesize
+                raise ParseException, 'compression corrupt', caller
+            end
+            result = binary_to_term_(0, data_uncompressed)
+            i_new = result[0]; term = result[1]
+            if i_new != size_uncompressed
+                raise ParseException, 'unparsed data', caller
+            end
+            return [i + j, term]
         else
             raise ParseException, 'invalid tag', caller
         end
     end
     
-    def binary_to_term_sequence(i, arity, data)
+    def self.binary_to_term_sequence(i, arity, data)
         sequence = []
         (0...arity).each do |arity_index|
             result = binary_to_term_(i, data)
             i = result[0]; element = result[1]
-            sequence.append(element)
+            sequence.push(element)
         end
         return [i, sequence]
     end
             
-    def binary_to_integer(i, data)
+    def self.binary_to_integer(i, data)
         tag = data[i].ord
         i += 1
         if tag == TAG_SMALL_INTEGER_EXT
@@ -439,7 +557,7 @@ module Erlang
         end
     end
     
-    def binary_to_pid(i, data)
+    def self.binary_to_pid(i, data)
         tag = data[i].ord
         i += 1
         if tag == TAG_PID_EXT
@@ -457,7 +575,7 @@ module Erlang
         end
     end
     
-    def binary_to_atom(i, data)
+    def self.binary_to_atom(i, data)
         tag = data[i].ord
         i += 1
         if tag == TAG_ATOM_EXT
@@ -495,11 +613,9 @@ module Erlang
     
     # term_to_binary
     
-    def term_to_binary_(term)
+    def self.term_to_binary_(term)
         if term.kind_of?(String)
             return string_to_binary(term)
-        elsif term.kind_of?(OtpErlangList)
-            return term.to_s
         elsif term.kind_of?(Array)
             return tuple_to_binary(term)
         elsif term.kind_of?(Float)
@@ -509,29 +625,35 @@ module Erlang
         elsif term.kind_of?(Hash)
             return hash_to_binary(term)
         elsif term.kind_of?(Symbol)
-            return OtpErlangAtom.new(term.to_s).to_s
+            return OtpErlangAtom.new(term.to_s).binary
         elsif term.kind_of?(TrueClass)
-            return OtpErlangAtom.new("true").to_s
+            return OtpErlangAtom.new(
+                'true'.force_encoding('ISO-8859-1')
+            ).binary
         elsif term.kind_of?(FalseClass)
-            return OtpErlangAtom.new("false").to_s
+            return OtpErlangAtom.new(
+                'false'.force_encoding('ISO-8859-1')
+            ).binary
         elsif term.kind_of?(OtpErlangAtom)
-            return term.to_s
+            return term.binary
+        elsif term.kind_of?(OtpErlangList)
+            return term.binary
         elsif term.kind_of?(OtpErlangBinary)
-            return term.to_s
+            return term.binary
         elsif term.kind_of?(OtpErlangFunction)
-            return term.to_s
+            return term.binary
         elsif term.kind_of?(OtpErlangReference)
-            return term.to_s
+            return term.binary
         elsif term.kind_of?(OtpErlangPort)
-            return term.to_s
+            return term.binary
         elsif term.kind_of?(OtpErlangPid)
-            return term.to_s
+            return term.binary
         else
             raise OutputException, 'unknown ruby type', caller
         end
     end
     
-    def string_to_binary(term)
+    def self.string_to_binary(term)
         arity = term.bytesize
         if arity == 0
             return TAG_NIL_EXT.chr
@@ -543,11 +665,12 @@ module Erlang
             term_packed = term.unpack("C#{arity}").map{ |c|
                 "#{TAG_SMALL_INTEGER_EXT.chr}#{c}"
             }.join
-            return "#{TAG_LIST_EXT.chr}#{arity_packed}#{term_packed}#{TAG_NIL_EXT.chr}"
+            return "#{TAG_LIST_EXT.chr}#{arity_packed}#{term_packed}" \
+                   "#{TAG_NIL_EXT.chr}"
         end
     end
     
-    def tuple_to_binary(term)
+    def self.tuple_to_binary(term)
         arity = term.length
         term_packed = term.map{ |element|
             term_to_binary_(element)
@@ -560,7 +683,7 @@ module Erlang
         end
     end
     
-    def integer_to_binary(term)
+    def self.integer_to_binary(term)
         if 0 <= term and term <= 255
             return "#{TAG_SMALL_INTEGER_EXT.chr}#{term.chr}"
         elsif -2147483648 <= term and term <= 2147483647
@@ -571,9 +694,9 @@ module Erlang
         end
     end
     
-    def bignum_to_binary(term)
+    def self.bignum_to_binary(term)
         bignum = term.abs
-        size = Integer.new(Math.log(bignum) / Math.log(256)) + 1
+        size = (bignum_bit_length(bignum) / 8.0).ceil.to_i
         if term < 0
             sign = 1.chr
         else
@@ -581,7 +704,7 @@ module Erlang
         end
         l = [sign]
         (0...size).each do |byte|
-            l.append((bignum & 255).chr)
+            l.push((bignum & 255).chr)
             bignum >>= 8
         end
         if size < 256
@@ -591,13 +714,17 @@ module Erlang
             return "#{TAG_LARGE_BIG_EXT.chr}#{size_packed}#{l.join}"
         end
     end
+
+    def self.bignum_bit_length(bignum)
+        return bignum.to_s(2).bytesize
+    end
     
-    def float_to_binary(term)
+    def self.float_to_binary(term)
         term_packed = [term].pack('G')
         return "#{TAG_NEW_FLOAT_EXT.chr}#{term_packed}"
     end
 
-    def hash_to_binary(term)
+    def self.hash_to_binary(term)
         arity = term.length
         term_packed = term.to_a.map{ |element|
             key_packed = term_to_binary_(element[0])
@@ -613,11 +740,15 @@ module Erlang
     class ParseException < SyntaxError
     end
     
+    class InputException < ArgumentError
+    end
+
     class OutputException < TypeError
     end
 
     # tag values here http://www.erlang.org/doc/apps/erts/erl_ext_dist.html
     TAG_VERSION = 131
+    TAG_COMPRESSED_ZLIB = 80
     TAG_NEW_FLOAT_EXT = 70
     TAG_BIT_BINARY_EXT = 77
     TAG_ATOM_CACHE_REF = 78

data/tests/erlang_tests.rb

@@ -0,0 +1,620 @@
+#!/usr/bin/env ruby
+#-*-Mode:ruby;coding:binary;tab-width:4;c-basic-offset:4;indent-tabs-mode:()-*-
+# ex: set ft=ruby fenc=binary sts=4 ts=4 sw=4 et:
+#
+# BSD LICENSE
+# 
+# Copyright (c) 2014, Michael Truog <mjtruog at gmail dot com>
+# Copyright (c) 2009-2013, Dmitry Vasiliev <dima@hlabs.org>
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met
+# 
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in
+#       the documentation and/or other materials provided with the
+#       distribution.
+#     * All advertising materials mentioning features or use of this
+#       software must display the following acknowledgment
+#         This product includes software developed by Michael Truog
+#     * The name of the author may not be used to endorse or promote
+#       products derived from this software without specific prior
+#       written permission
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+# DAMAGE.
+#
+
+path = File.split(File.dirname(__FILE__)); path.pop(1)
+$:.unshift File.join(*path, *%w[lib])
+require 'test/unit'
+require 'erlang'
+
+# many of the test cases were adapted
+# from erlport (https://github.com/hdima/erlport)
+# to make the tests more exhaustive
+
+class AtomTestCase < Test::Unit::TestCase
+    def test_atom
+        atom1 = Erlang::OtpErlangAtom.new('test')
+        assert(atom1.kind_of?(Erlang::OtpErlangAtom))
+        assert_equal(Erlang::OtpErlangAtom.new('test'), atom1)
+        assert_equal("Erlang::OtpErlangAtom('test')", atom1.to_s)
+        atom2 = Erlang::OtpErlangAtom.new('test2')
+        atom1_new = Erlang::OtpErlangAtom.new('test')
+        assert_not_equal(atom1, atom2)
+        assert_not_equal(atom1.hash, atom2.hash)
+        assert_equal(atom1, atom1_new)
+        assert_equal(atom1.hash, atom1_new.hash)
+        assert_equal('X' * 255, Erlang::OtpErlangAtom.new('X' * 255).value)
+        assert_equal('X' * 256, Erlang::OtpErlangAtom.new('X' * 256).value)
+    end
+    def test_invalid_atom
+        assert_raise(Erlang::OutputException){
+            Erlang::OtpErlangAtom.new([1, 2]).binary
+        }
+    end
+end
+
+class ListTestCase < Test::Unit::TestCase
+    def test_list
+        lst = Erlang::OtpErlangList.new([116, 101, 115, 116])
+        assert(lst.kind_of?(Erlang::OtpErlangList))
+        assert_equal(Erlang::OtpErlangList.new([116, 101, 115, 116]), lst)
+        assert_equal([116, 101, 115, 116], lst.value)
+        assert_equal('Erlang::OtpErlangList([116, 101, 115, 116],' \
+                                           'improper=false)', lst.to_s)
+    end
+end
+
+class ImproperListTestCase < Test::Unit::TestCase
+    def test_improper_list
+        lst = Erlang::OtpErlangList.new([1, 2, 3, 4], improper=true)
+        assert(lst.kind_of?(Erlang::OtpErlangList))
+        assert_equal(Erlang::OtpErlangList.new([1, 2, 3, 4]).value, lst.value)
+        assert_equal(4, lst.value[-1])
+        assert_equal('Erlang::OtpErlangList([1, 2, 3, 4],' \
+                                           'improper=true)', lst.to_s)
+    end
+    def test_comparison
+        lst = Erlang::OtpErlangList.new([1, 2, 3, 4], improper=true)
+        assert_equal(lst, lst)
+        assert_equal(lst,
+                     Erlang::OtpErlangList.new([1, 2, 3, 4], improper=true))
+        assert_not_equal(lst,
+                         Erlang::OtpErlangList.new([1, 2, 3, 5], improper=true))
+        assert_not_equal(lst,
+                         Erlang::OtpErlangList.new([1, 2, 3], improper=true))
+    end
+    def test_errors
+        assert_raise(Erlang::OutputException){
+            Erlang::OtpErlangList.new('invalid', improper=true).binary
+        }
+    end
+end
+
+class DecodeTestCase < Test::Unit::TestCase
+    def test_binary_to_term
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83z")
+        }
+    end
+    def test_binary_to_term_atom
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83d")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83d\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83d\0\1")
+        }
+        assert_equal(:'', Erlang::binary_to_term("\x83d\0\0"))
+        assert_equal(:'', Erlang::binary_to_term("\x83s\0"))
+        assert_equal(:test, Erlang::binary_to_term("\x83d\0\4test"))
+        assert_equal(:test, Erlang::binary_to_term("\x83s\4test"))
+    end
+    def test_binary_to_term_predefined_atoms
+        assert_equal(true,
+                     Erlang::binary_to_term("\x83s\4true"))
+        assert_equal(false,
+                     Erlang::binary_to_term("\x83s\5false"))
+        assert_equal(:undefined,
+                     Erlang::binary_to_term("\x83d\0\11undefined"))
+    end
+    def test_binary_to_term_empty_list
+        assert_equal(Erlang::OtpErlangList.new([]),
+                     Erlang::binary_to_term("\x83j"))
+    end
+    def test_binary_to_term_string_list
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83k")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83k\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83k\0\1")
+        }
+        assert_equal('', Erlang::binary_to_term("\x83k\0\0"))
+        assert_equal('test', Erlang::binary_to_term("\x83k\0\4test"))
+    end
+    def test_binary_to_term_list
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83l")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83l\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83l\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83l\0\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83l\0\0\0\0")
+        }
+        assert_equal(Erlang::OtpErlangList.new([]),
+                     Erlang::binary_to_term("\x83l\0\0\0\0j"))
+        assert_equal(Erlang::OtpErlangList.new([Erlang::OtpErlangList.new([]),
+                                                Erlang::OtpErlangList.new([])]),
+                     Erlang::binary_to_term("\x83l\0\0\0\2jjj"))
+    end
+    def test_binary_to_term_improper_list
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83l\0\0\0\0k")
+        }
+        lst = Erlang::binary_to_term("\x83l\0\0\0\1jd\0\4tail")
+        assert(lst.kind_of?(Erlang::OtpErlangList))
+        assert_equal([Erlang::OtpErlangList.new([]), :tail], lst.value)
+        assert_equal(true, lst.improper)
+    end
+    def test_binary_to_term_small_tuple
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83h")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83h\1")
+        }
+        assert(Erlang::binary_to_term("\x83h\0").kind_of?(Array))
+        assert_equal([], Erlang::binary_to_term("\x83h\0"))
+        assert_equal([Erlang::OtpErlangList.new([]),
+                      Erlang::OtpErlangList.new([])],
+                     Erlang::binary_to_term("\x83h\2jj"))
+    end
+    def test_binary_to_term_large_tuple
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83i")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83i\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83i\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83i\0\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83i\0\0\0\1")
+        }
+        assert_equal([], Erlang::binary_to_term("\x83i\0\0\0\0"))
+        assert_equal([Erlang::OtpErlangList.new([]),
+                      Erlang::OtpErlangList.new([])],
+                     Erlang::binary_to_term("\x83i\0\0\0\2jj"))
+    end
+    def test_binary_to_term_small_integer
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83a")
+        }
+        assert_equal(0, Erlang::binary_to_term("\x83a\0"))
+        assert_equal(255, Erlang::binary_to_term("\x83a\xff"))
+    end
+    def test_binary_to_term_integer
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83b")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83b\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83b\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83b\0\0\0")
+        }
+        assert_equal(0, Erlang::binary_to_term("\x83b\0\0\0\0"))
+        assert_equal(2147483647,
+                     Erlang::binary_to_term("\x83b\x7f\xff\xff\xff"))
+        assert_equal(-2147483648,
+                     Erlang::binary_to_term("\x83b\x80\0\0\0"))
+        assert_equal(-1, Erlang::binary_to_term("\x83b\xff\xff\xff\xff"))
+    end
+    def test_binary_to_term_binary
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83m")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83m\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83m\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83m\0\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83m\0\0\0\1")
+        }
+        assert_equal(Erlang::OtpErlangBinary.new(""),
+                     Erlang::binary_to_term("\x83m\0\0\0\0"))
+        assert_equal(Erlang::OtpErlangBinary.new("data"),
+                     Erlang::binary_to_term("\x83m\0\0\0\4data"))
+    end
+    def test_binary_to_term_float
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83F")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83F\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83F\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83F\0\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83F\0\0\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83F\0\0\0\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83F\0\0\0\0\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83F\0\0\0\0\0\0\0")
+        }
+        assert_equal(0.0, Erlang::binary_to_term("\x83F\0\0\0\0\0\0\0\0"))
+        assert_equal(1.5, Erlang::binary_to_term("\x83F?\xf8\0\0\0\0\0\0"))
+    end
+    def test_binary_to_term_small_big_integer
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83n")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83n\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83n\1\0")
+        }
+        assert_equal(0, Erlang::binary_to_term("\x83n\0\0"))
+        assert_equal(6618611909121,
+                     Erlang::binary_to_term("\x83n\6\0\1\2\3\4\5\6"))
+        assert_equal(-6618611909121,
+                     Erlang::binary_to_term("\x83n\6\1\1\2\3\4\5\6"))
+    end
+    def test_binary_to_term_big_integer
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83o")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83o\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83o\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83o\0\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83o\0\0\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83o\0\0\0\1\0")
+        }
+        assert_equal(0, Erlang::binary_to_term("\x83o\0\0\0\0\0"))
+        assert_equal(6618611909121,
+                     Erlang::binary_to_term("\x83o\0\0\0\6\0\1\2\3\4\5\6"))
+        assert_equal(-6618611909121,
+                     Erlang::binary_to_term("\x83o\0\0\0\6\1\1\2\3\4\5\6"))
+    end
+    def test_binary_to_term_compressed_term
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83P")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83P\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83P\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83P\0\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83P\0\0\0\0")
+        }
+        assert_raise(Erlang::ParseException){
+            Erlang::binary_to_term("\x83P\0\0\0\x16\x78\xda\xcb\x66" \
+                                   "\x10\x49\xc1\2\0\x5d\x60\x08\x50")
+        }
+        assert_equal("d" * 20,
+            Erlang::binary_to_term("\x83P\0\0\0\x17\x78\xda\xcb\x66" \
+                                   "\x10\x49\xc1\2\0\x5d\x60\x08\x50")
+        )
+    end
+end
+
+class EncodeTestCase < Test::Unit::TestCase
+    def test_term_to_binary_tuple
+        assert_equal("\x83h\0", Erlang::term_to_binary([]))
+        assert_equal("\x83h\2h\0h\0",
+                     Erlang::term_to_binary([[], []]))
+        assert_equal("\x83h\xff" + "h\0" * 255,
+                     Erlang::term_to_binary([[]] * 255))
+        assert_equal("\x83i\0\0\1\0" + "h\0" * 256,
+                     Erlang::term_to_binary([[]] * 256))
+    end
+    def test_term_to_binary_empty_list
+        assert_equal("\x83j",
+                     Erlang::term_to_binary(Erlang::OtpErlangList.new([])))
+    end
+    def test_term_to_binary_string_list
+        assert_equal("\x83k\0\1\0", Erlang::term_to_binary("\0"))
+        s = (0...256).to_a.map{ |i| i.chr }.join
+        assert_equal("\x83k\1\0" + s, Erlang::term_to_binary(s))
+    end
+    def test_term_to_binary_list_basic
+        assert_equal("\x83\x6A",
+                     Erlang::term_to_binary(Erlang::OtpErlangList.new([])))
+        assert_equal("\x83\x6C\x00\x00\x00\x01\x6A\x6A",
+                     Erlang::term_to_binary(Erlang::OtpErlangList.new([""])))
+        assert_equal("\x83\x6C\x00\x00\x00\x01\x61\x01\x6A",
+                     Erlang::term_to_binary(Erlang::OtpErlangList.new([1])))
+        assert_equal("\x83\x6C\x00\x00\x00\x01\x61\xFF\x6A",
+                     Erlang::term_to_binary(Erlang::OtpErlangList.new([255])))
+        assert_equal("\x83\x6C\x00\x00\x00\x01\x62\x00\x00\x01\x00\x6A",
+                     Erlang::term_to_binary(Erlang::OtpErlangList.new([256])))
+        assert_equal(
+            "\x83\x6C\x00\x00\x00\x01\x62\x7F\xFF\xFF\xFF\x6A",
+            Erlang::term_to_binary(Erlang::OtpErlangList.new([2147483647]))
+        )
+        assert_equal(
+            "\x83\x6C\x00\x00\x00\x01\x6E\x04\x00\x00\x00\x00\x80\x6A",
+            Erlang::term_to_binary(Erlang::OtpErlangList.new([2147483648]))
+        )
+        assert_equal("\x83\x6C\x00\x00\x00\x01\x61\x00\x6A",
+                     Erlang::term_to_binary(Erlang::OtpErlangList.new([0])))
+        assert_equal("\x83\x6C\x00\x00\x00\x01\x62\xFF\xFF\xFF\xFF\x6A",
+                     Erlang::term_to_binary(Erlang::OtpErlangList.new([-1])))
+        assert_equal("\x83\x6C\x00\x00\x00\x01\x62\xFF\xFF\xFF\x00\x6A",
+                     Erlang::term_to_binary(Erlang::OtpErlangList.new([-256])))
+        assert_equal("\x83\x6C\x00\x00\x00\x01\x62\xFF\xFF\xFE\xFF\x6A",
+                     Erlang::term_to_binary(Erlang::OtpErlangList.new([-257])))
+        assert_equal(
+            "\x83\x6C\x00\x00\x00\x01\x62\x80\x00\x00\x00\x6A",
+            Erlang::term_to_binary(Erlang::OtpErlangList.new([-2147483648]))
+        )
+        assert_equal(
+            "\x83\x6C\x00\x00\x00\x01\x6E\x04\x01\x01\x00\x00\x80\x6A",
+            Erlang::term_to_binary(Erlang::OtpErlangList.new([-2147483649]))
+        )
+        assert_equal(
+            "\x83\x6C\x00\x00\x00\x01\x6B\x00\x04\x74\x65\x73\x74\x6A",
+            Erlang::term_to_binary(Erlang::OtpErlangList.new(["test"]))
+        )
+        assert_equal(
+            "\x83\x6C\x00\x00\x00\x02\x62\x00\x00\x01\x75\x62\x00\x00" \
+            "\x01\xC7\x6A",
+            Erlang::term_to_binary(Erlang::OtpErlangList.new([373, 455]))
+        )
+        assert_equal(
+            "\x83\x6C\x00\x00\x00\x01\x6A\x6A",
+            Erlang::term_to_binary(
+                Erlang::OtpErlangList.new([Erlang::OtpErlangList.new([])])
+            )
+        )
+        assert_equal(
+            "\x83\x6C\x00\x00\x00\x02\x6A\x6A\x6A",
+            Erlang::term_to_binary(
+                Erlang::OtpErlangList.new([Erlang::OtpErlangList.new([]),
+                                           Erlang::OtpErlangList.new([])])
+            )
+        )
+        assert_equal(
+            "\x83\x6C\x00\x00\x00\x03\x6C\x00\x00\x00\x02\x6B\x00\x04\x74\x68" \
+            "\x69\x73\x6B\x00\x02\x69\x73\x6A\x6C\x00\x00\x00\x01\x6C\x00\x00" \
+            "\x00\x01\x6B\x00\x01\x61\x6A\x6A\x6B\x00\x04\x74\x65\x73\x74\x6A",
+            Erlang::term_to_binary(Erlang::OtpErlangList.new([
+                Erlang::OtpErlangList.new(["this", "is"]),
+                Erlang::OtpErlangList.new([
+                    Erlang::OtpErlangList.new(["a"])
+                ]),
+                "test"
+            ]))
+        )
+    end
+    def test_term_to_binary_list
+        assert_equal(
+            "\x83l\0\0\0\1jj",
+            Erlang::term_to_binary(Erlang::OtpErlangList.new([
+                Erlang::OtpErlangList.new([])
+            ]))
+        )
+        assert_equal(
+            "\x83l\0\0\0\5jjjjjj",
+            Erlang::term_to_binary(Erlang::OtpErlangList.new([
+                Erlang::OtpErlangList.new([]),
+                Erlang::OtpErlangList.new([]),
+                Erlang::OtpErlangList.new([]),
+                Erlang::OtpErlangList.new([]),
+                Erlang::OtpErlangList.new([])
+            ]))
+        )
+    end
+    def test_term_to_binary_improper_list
+        assert_equal(
+            "\x83l\0\0\0\1h\0h\0",
+            Erlang::term_to_binary(Erlang::OtpErlangList.new([
+                [], []
+            ], improper=true))
+        )
+        assert_equal(
+            "\x83l\0\0\0\1a\0a\1",
+            Erlang::term_to_binary(Erlang::OtpErlangList.new([
+                0, 1
+            ], improper=true))
+        )
+    end
+    def test_term_to_binary_atom
+        assert_equal("\x83s\0", Erlang::term_to_binary(:""))
+        assert_equal("\x83s\4test", Erlang::term_to_binary(:test))
+    end
+    def test_term_to_binary_string_basic
+        assert_equal("\x83\x6A", Erlang::term_to_binary(""))
+        assert_equal("\x83\x6B\x00\x04\x74\x65\x73\x74",
+                     Erlang::term_to_binary("test"))
+        assert_equal(
+            "\x83\x6B\x00\x09\x74\x77\x6F\x20\x77\x6F\x72\x64\x73",
+            Erlang::term_to_binary("two words")
+        )
+        assert_equal(
+            "\x83\x6B\x00\x16\x74\x65\x73\x74\x69\x6E\x67\x20\x6D\x75\x6C\x74" \
+            "\x69\x70\x6C\x65\x20\x77\x6F\x72\x64\x73",
+            Erlang::term_to_binary("testing multiple words")
+        )
+        assert_equal("\x83\x6B\x00\x01\x20",
+                         Erlang::term_to_binary(" "))
+        assert_equal("\x83\x6B\x00\x02\x20\x20",
+                         Erlang::term_to_binary("  "))
+        assert_equal("\x83\x6B\x00\x01\x31",
+                         Erlang::term_to_binary("1"))
+        assert_equal("\x83\x6B\x00\x02\x33\x37",
+                         Erlang::term_to_binary("37"))
+        assert_equal("\x83\x6B\x00\x07\x6F\x6E\x65\x20\x3D\x20\x31",
+                         Erlang::term_to_binary("one = 1"))
+        assert_equal(
+            "\x83\x6B\x00\x20\x21\x40\x23\x24\x25\x5E\x26\x2A\x28\x29\x5F\x2B" \
+            "\x2D\x3D\x5B\x5D\x7B\x7D\x5C\x7C\x3B\x27\x3A\x22\x2C\x2E\x2F\x3C" \
+            "\x3E\x3F\x7E\x60",
+            Erlang::term_to_binary("!@#\$%^&*()_+-=[]{}\\|;':\",./<>?~`")
+        )
+        assert_equal(
+            "\x83\x6B\x00\x09\x22\x08\x0C\x0A\x0D\x09\x0B\x53\x12",
+            Erlang::term_to_binary("\"\b\f\n\r\t\v\123\x12")
+        )
+    end
+    def test_term_to_binary_string
+        assert_equal("\x83j", Erlang::term_to_binary(''))
+        assert_equal("\x83k\0\1\0",
+                     Erlang::term_to_binary("\0"))
+        assert_equal("\x83k\0\4test",
+                     Erlang::term_to_binary('test'))
+    end
+    def test_term_to_binary_boolean
+        assert_equal("\x83s\4true", Erlang::term_to_binary(true))
+        assert_equal("\x83s\5false", Erlang::term_to_binary(false))
+    end
+    def test_term_to_binary_short_integer
+        assert_equal("\x83a\0", Erlang::term_to_binary(0))
+        assert_equal("\x83a\xff", Erlang::term_to_binary(255))
+    end
+    def test_term_to_binary_integer
+        assert_equal("\x83b\xff\xff\xff\xff", Erlang::term_to_binary(-1))
+        assert_equal("\x83b\x80\0\0\0",
+                     Erlang::term_to_binary(-2147483648))
+        assert_equal("\x83b\0\0\1\0",
+                     Erlang::term_to_binary(256))
+        assert_equal("\x83b\x7f\xff\xff\xff",
+                     Erlang::term_to_binary(2147483647))
+    end
+    def test_term_to_binary_long_integer
+        assert_equal("\x83n\4\0\0\0\0\x80",
+                     Erlang::term_to_binary(2147483648))
+        assert_equal("\x83n\4\1\1\0\0\x80",
+                     Erlang::term_to_binary(-2147483649))
+        assert_equal("\x83o\0\0\1\0\0" + "\0" * 255 + "\1",
+                     Erlang::term_to_binary(2 ** 2040))
+        assert_equal("\x83o\0\0\1\0\1" + "\0" * 255 + "\1",
+                     Erlang::term_to_binary(-2 ** 2040))
+    end
+    def test_term_to_binary_float
+        assert_equal("\x83F\0\0\0\0\0\0\0\0",
+                     Erlang::term_to_binary(0.0))
+        assert_equal("\x83F?\xe0\0\0\0\0\0\0",
+                     Erlang::term_to_binary(0.5))
+        assert_equal("\x83F\xbf\xe0\0\0\0\0\0\0",
+                     Erlang::term_to_binary(-0.5))
+        assert_equal("\x83F@\t!\xfbM\x12\xd8J",
+                     Erlang::term_to_binary(3.1415926))
+        assert_equal("\x83F\xc0\t!\xfbM\x12\xd8J",
+                     Erlang::term_to_binary(-3.1415926))
+    end
+    def test_term_to_binary_compressed_term
+        assert_equal(
+            "\x83P\x00\x00\x00\x15x\x9c\xcba``\xe0\xcfB\x03\x00B@\x07\x1c",
+            Erlang::term_to_binary(
+                Erlang::OtpErlangList.new([
+                    Erlang::OtpErlangList.new([])
+                ] * 15), compressed=true
+            )
+        )
+        assert_equal(
+            "\x83P\x00\x00\x00\x15x\x9c\xcba``\xe0\xcfB\x03\x00B@\x07\x1c",
+            Erlang::term_to_binary(
+                Erlang::OtpErlangList.new([
+                    Erlang::OtpErlangList.new([])
+                ] * 15), compressed=6
+            )
+        )
+        assert_equal(
+            "\x83P\x00\x00\x00\x15x\xda\xcba``\xe0\xcfB\x03\x00B@\x07\x1c",
+            Erlang::term_to_binary(
+                Erlang::OtpErlangList.new([
+                    Erlang::OtpErlangList.new([])
+                ] * 15), compressed=9
+            )
+        )
+        assert_equal(
+            "\x83P\x00\x00\x00\x15x\x01\x01\x15\x00\xea\xffl\x00\x00\x00" \
+            "\x0fjjjjjjjjjjjjjjjjB@\x07\x1c",
+            Erlang::term_to_binary(
+                Erlang::OtpErlangList.new([
+                    Erlang::OtpErlangList.new([])
+                ] * 15), compressed=0
+            )
+        )
+        assert_equal(
+            "\x83P\0\0\0\x17\x78\xda\xcb\x66\x10\x49\xc1\2\0\x5d\x60\x08\x50",
+            Erlang::term_to_binary("d" * 20, compressed=9)
+        )
+    end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: erlang_rb
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.3.3
   prerelease: 
 platform: ruby
 authors:
@@ -50,7 +50,7 @@ cert_chain:
   -----END CERTIFICATE-----
 
 '
-date: 2014-06-24 00:00:00.000000000 Z
+date: 2014-09-30 00:00:00.000000000 Z
 dependencies: []
 description: Erlang Binary Term Format for Ruby
 email: mjtruog@gmail.com
@@ -61,6 +61,7 @@ extra_rdoc_files:
 files:
 - lib/erlang.rb
 - README.markdown
+- tests/erlang_tests.rb
 homepage: https://github.com/okeuday/erlang_rb
 licenses:
 - BSD
@@ -86,4 +87,5 @@ rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Erlang
-test_files: []
+test_files:
+- tests/erlang_tests.rb