/priv/ruby1.9/test/erlterms_tests.rb
Ruby | 473 lines | 436 code | 10 blank | 27 comment | 0 complexity | d39f5d995b17e3f6d8c15cc02fec8fc3 MD5 | raw file
Possible License(s): BSD-3-Clause
- # encoding: binary
- # Copyright (c) 2009-2015, 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.
- # * Neither the name of the copyright holders nor the names of its
- # contributors may 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 HOLDER 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.
- require 'test/unit'
- require 'erlport/erlterms'
- include ErlPort::ErlTerm
- class TupleTestCase < Test::Unit::TestCase
- def test_tuple
- tuple = Tuple.new([1, 2, 3])
- assert_equal Tuple, tuple.class
- assert_equal 3, tuple.length
- assert_equal 1, tuple[0]
- assert_equal 2, tuple[1]
- assert_equal 3, tuple[2]
- assert_equal [1, 2, 3], tuple.to_a
- end
- def test_multiple_assignment
- tuple = Tuple.new([1, 2, 3])
- a, b, c = tuple
- assert_equal a, 1
- assert_equal b, 2
- assert_equal c, 3
- end
- def test_comparison
- tuple = Tuple.new([1, 2, 3])
- assert_equal tuple, tuple
- assert_equal tuple, Tuple.new([1, 2, 3])
- assert_not_equal tuple, Tuple.new([3, 2, 1])
- end
- end
- class OpaqueObjectTestCase < Test::Unit::TestCase
- def test_opaque_object
- obj = OpaqueObject.new "data", :language
- assert_equal "data", obj.data
- assert_equal :language, obj.language
- assert_raise(TypeError){OpaqueObject.new("data", "language")}
- assert_raise(TypeError){OpaqueObject.new([1, 2], :language)}
- end
- def test_comparison
- obj = OpaqueObject.new "data", :language
- assert_equal obj, obj
- assert_equal obj, OpaqueObject.new("data", :language)
- assert_not_equal obj, OpaqueObject.new("data", :language2)
- assert_not_equal obj, OpaqueObject.new("data2", :language)
- end
- def test_decode
- obj = OpaqueObject.decode "data", :language
- assert_equal "data", obj.data
- assert_equal :language, obj.language
- end
- def test_decode_ruby
- data = OpaqueObject.decode "\004\b\"\ttest", :ruby
- assert_equal "test", data
- end
- def test_encode
- obj = OpaqueObject.new("data", :language)
- term = Tuple.new([:"$erlport.opaque", :language, "data"])
- assert_equal encode(term), "\x83" + obj.encode()
- end
- def test_encode_erlang
- obj = OpaqueObject.new "data", :erlang
- assert_equal "data", obj.encode
- end
- def test_hashing
- obj = OpaqueObject.new "data", :language
- obj2 = OpaqueObject.new "data", :language
- assert_equal obj.hash, obj2.hash
- obj3 = OpaqueObject.new "data", :language2
- assert_not_equal obj.hash, obj3.hash
- obj4 = OpaqueObject.new "data2", :language
- assert_not_equal obj.hash, obj4.hash
- end
- end
- class ImproperListTestCase < Test::Unit::TestCase
- def test_improper_list
- improper = ImproperList.new [1, 2, 3], "tail"
- assert_equal ImproperList, improper.class
- assert_equal [1, 2, 3], improper
- assert_equal "tail", improper.tail
- end
- def test_comparison
- improper = ImproperList.new [1, 2, 3], "tail"
- assert_equal improper, improper
- assert_equal improper, ImproperList.new([1, 2, 3], "tail")
- assert_not_equal improper, ImproperList.new([1, 2, 3], "tail2")
- assert_not_equal improper, ImproperList.new([1, 2], "tail")
- end
- def test_hashing
- hash = ImproperList.new([1, 2, 3], "tail").hash
- assert_equal hash, ImproperList.new([1, 2, 3], "tail").hash
- assert_not_equal hash, ImproperList.new([1, 2, 3], "tail2").hash
- assert_not_equal hash, ImproperList.new([1, 2], "tail").hash
- end
- def test_errors
- assert_raise(TypeError){ImproperList.new([1, 2, 3], ["invalid"])}
- assert_raise(ValueError){ImproperList.new([], "tail")}
- end
- end
- class DecodeTestCase < Test::Unit::TestCase
- def test_decode
- assert_raise(IncompleteData){decode("")}
- assert_raise(ValueError){decode("\0")}
- assert_raise(IncompleteData){decode("\x83")}
- assert_raise(ValueError){decode("\x83z")}
- end
- def test_decode_atom
- assert_raise(IncompleteData){decode("\x83d")}
- assert_raise(IncompleteData){decode("\x83d\0")}
- assert_raise(IncompleteData){decode("\x83d\0\1")}
- assert_equal [:"", ""], decode("\x83d\0\0")
- assert_equal [:"", "tail"], decode("\x83d\0\0tail")
- assert_equal [:test, ""], decode("\x83d\0\4test")
- assert_equal [:test, "tail"], decode("\x83d\0\4testtail")
- end
- def test_decode_predefined_atoms
- assert_equal [true, ""], decode("\x83d\0\4true")
- assert_equal [true, "tail"], decode("\x83d\0\4truetail")
- assert_equal [false, ""], decode("\x83d\0\5false")
- assert_equal [false, "tail"], decode("\x83d\0\5falsetail")
- assert_equal [nil, ""], decode("\x83d\0\11undefined")
- assert_equal [nil, "tail"], decode("\x83d\0\11undefinedtail")
- end
- def test_decode_empty_list
- assert_equal [[], ""], decode("\x83j")
- assert_equal [[], "tail"], decode("\x83jtail")
- end
- def test_decode_string_list
- assert_raise(IncompleteData){decode("\x83k")}
- assert_raise(IncompleteData){decode("\x83k\0")}
- assert_raise(IncompleteData){decode("\x83k\0\1")}
- # Erlang use 'j' tag for empty lists
- assert_equal [[], ""], decode("\x83k\0\0")
- assert_equal [[], "tail"], decode("\x83k\0\0tail")
- assert_equal [[116, 101, 115, 116], ""], decode("\x83k\0\4test")
- assert_equal [[116, 101, 115, 116], "tail"],
- decode("\x83k\0\4testtail")
- end
- def test_decode_list
- assert_raise(IncompleteData){decode("\x83l")}
- assert_raise(IncompleteData){decode("\x83l\0")}
- assert_raise(IncompleteData){decode("\x83l\0\0")}
- assert_raise(IncompleteData){decode("\x83l\0\0\0")}
- assert_raise(IncompleteData){decode("\x83l\0\0\0\0")}
- # Erlang use 'j' tag for empty lists
- assert_equal [[], ""], decode("\x83l\0\0\0\0j")
- assert_equal [[], "tail"], decode("\x83l\0\0\0\0jtail")
- assert_equal [[[], []], ""], decode("\x83l\0\0\0\2jjj")
- assert_equal [[[], []], "tail"], decode("\x83l\0\0\0\2jjjtail")
- end
- def test_decode_improper_list
- assert_raise(IncompleteData){decode("\x83l\0\0\0\0k")}
- improper, tail = decode("\x83l\0\0\0\1jd\0\4tail")
- assert_equal ImproperList, improper.class
- assert_equal [[]], improper
- assert_equal Symbol, improper.tail.class
- assert_equal :tail, improper.tail
- assert_equal "", tail
- improper, tail = decode("\x83l\0\0\0\1jd\0\4tailtail")
- assert_equal ImproperList, improper.class
- assert_equal [[]], improper
- assert_equal Symbol, improper.tail.class
- assert_equal :tail, improper.tail
- assert_equal "tail", tail
- end
- def test_decode_small_tuple
- assert_raise(IncompleteData){decode("\x83h")}
- assert_raise(IncompleteData){decode("\x83h\1")}
- assert_equal Tuple, decode("\x83h\0")[0].class
- assert_equal [Tuple.new([]), ""], decode("\x83h\0")
- assert_equal [Tuple.new([]), "tail"], decode("\x83h\0tail")
- assert_equal [Tuple.new([[], []]), ""], decode("\x83h\2jj")
- assert_equal [Tuple.new([[], []]), "tail"], decode("\x83h\2jjtail")
- end
- def test_decode_large_tuple
- assert_raise(IncompleteData){decode("\x83i")}
- assert_raise(IncompleteData){decode("\x83i\0")}
- assert_raise(IncompleteData){decode("\x83i\0\0")}
- assert_raise(IncompleteData){decode("\x83i\0\0\0")}
- assert_raise(IncompleteData){decode("\x83i\0\0\0\1")}
- # Erlang use 'h' tag for small tuples
- assert_equal [Tuple.new([]), ""], decode("\x83i\0\0\0\0")
- assert_equal [Tuple.new([]), "tail"], decode("\x83i\0\0\0\0tail")
- assert_equal [Tuple.new([[], []]), ""], decode("\x83i\0\0\0\2jj")
- assert_equal [Tuple.new([[], []]), "tail"],
- decode("\x83i\0\0\0\2jjtail")
- end
- def test_decode_opaque_object
- opaque, tail = decode("\x83h\3d\0\x0f$erlport.opaqued\0\10language" \
- "m\0\0\0\4data")
- assert_equal OpaqueObject, opaque.class
- assert_equal "data", opaque.data
- assert_equal :language, opaque.language
- assert_equal "", tail
- opaque, tail = decode("\x83h\3d\0\x0f$erlport.opaqued\0\10language" \
- "m\0\0\0\4datatail")
- assert_equal OpaqueObject, opaque.class
- assert_equal "data", opaque.data
- assert_equal :language, opaque.language
- assert_equal "tail", tail
- end
- def test_decode_ruby_opaque_object
- opaque, tail = decode("\x83h\3d\0\x0f$erlport.opaqued\0\4ruby" \
- "m\0\0\0\10\4\b\"\ttest")
- assert_equal String, opaque.class
- assert_equal "test", opaque
- assert_equal "", tail
- opaque, tail = decode("\x83h\3d\0\x0f$erlport.opaqued\0\4ruby" \
- "m\0\0\0\10\4\b\"\ttesttail")
- assert_equal String, opaque.class
- assert_equal "test", opaque
- assert_equal "tail", tail
- end
- def test_decode_small_integer
- assert_raise(IncompleteData){decode("\x83a")}
- assert_equal [0, ""], decode("\x83a\0")
- assert_equal [0, "tail"], decode("\x83a\0tail")
- assert_equal [255, ""], decode("\x83a\xff")
- assert_equal [255, "tail"], decode("\x83a\xfftail")
- end
- def test_decode_integer
- assert_raise(IncompleteData){decode("\x83b")}
- assert_raise(IncompleteData){decode("\x83b\0")}
- assert_raise(IncompleteData){decode("\x83b\0\0")}
- assert_raise(IncompleteData){decode("\x83b\0\0\0")}
- # Erlang use 'a' tag for small integers
- assert_equal [0, ""], decode("\x83b\0\0\0\0")
- assert_equal [0, "tail"], decode("\x83b\0\0\0\0tail")
- assert_equal [2147483647, ""], decode("\x83b\x7f\xff\xff\xff")
- assert_equal [2147483647, "tail"], decode("\x83b\x7f\xff\xff\xfftail")
- assert_equal [-2147483648, ""], decode("\x83b\x80\0\0\0")
- assert_equal [-2147483648, "tail"], decode("\x83b\x80\0\0\0tail")
- assert_equal [-1, ""], decode("\x83b\xff\xff\xff\xff")
- assert_equal [-1, "tail"], decode("\x83b\xff\xff\xff\xfftail")
- end
- def test_decode_binary
- assert_raise(IncompleteData){decode("\x83m")}
- assert_raise(IncompleteData){decode("\x83m\0")}
- assert_raise(IncompleteData){decode("\x83m\0\0")}
- assert_raise(IncompleteData){decode("\x83m\0\0\0")}
- assert_raise(IncompleteData){decode("\x83m\0\0\0\1")}
- assert_equal ["", ""], decode("\x83m\0\0\0\0")
- assert_equal ["", "tail"], decode("\x83m\0\0\0\0tail")
- assert_equal ["data", ""], decode("\x83m\0\0\0\4data")
- assert_equal ["data", "tail"], decode("\x83m\0\0\0\4datatail")
- end
- def test_decode_float
- assert_raise(IncompleteData){decode("\x83F")}
- assert_raise(IncompleteData){decode("\x83F\0")}
- assert_raise(IncompleteData){decode("\x83F\0\0")}
- assert_raise(IncompleteData){decode("\x83F\0\0\0")}
- assert_raise(IncompleteData){decode("\x83F\0\0\0\0")}
- assert_raise(IncompleteData){decode("\x83F\0\0\0\0\0")}
- assert_raise(IncompleteData){decode("\x83F\0\0\0\0\0\0")}
- assert_raise(IncompleteData){decode("\x83F\0\0\0\0\0\0\0")}
- assert_equal [0.0, ""], decode("\x83F\0\0\0\0\0\0\0\0")
- assert_equal [0.0, "tail"], decode("\x83F\0\0\0\0\0\0\0\0tail")
- assert_equal [1.5, ""], decode("\x83F?\xf8\0\0\0\0\0\0")
- assert_equal [1.5, "tail"], decode("\x83F?\xf8\0\0\0\0\0\0tail")
- end
- def test_decode_small_big_integer
- assert_raise(IncompleteData){decode("\x83n")}
- assert_raise(IncompleteData){decode("\x83n\0")}
- assert_raise(IncompleteData){decode("\x83n\1\0")}
- # Erlang use 'a' tag for small integers
- assert_equal [0, ""], decode("\x83n\0\0")
- assert_equal [0, "tail"], decode("\x83n\0\0tail")
- assert_equal [6618611909121, ""], decode("\x83n\6\0\1\2\3\4\5\6")
- assert_equal [-6618611909121, ""], decode("\x83n\6\1\1\2\3\4\5\6")
- assert_equal [6618611909121, "tail"],
- decode("\x83n\6\0\1\2\3\4\5\6tail")
- end
- def test_decode_big_integer
- assert_raise(IncompleteData){decode("\x83o")}
- assert_raise(IncompleteData){decode("\x83o\0")}
- assert_raise(IncompleteData){decode("\x83o\0\0")}
- assert_raise(IncompleteData){decode("\x83o\0\0\0")}
- assert_raise(IncompleteData){decode("\x83o\0\0\0\0")}
- assert_raise(IncompleteData){decode("\x83o\0\0\0\1\0")}
- # Erlang use 'a' tag for small integers
- assert_equal [0, ""], decode("\x83o\0\0\0\0\0")
- assert_equal [0, "tail"], decode("\x83o\0\0\0\0\0tail")
- assert_equal [6618611909121, ""], decode("\x83o\0\0\0\6\0\1\2\3\4\5\6")
- assert_equal [-6618611909121, ""],
- decode("\x83o\0\0\0\6\1\1\2\3\4\5\6")
- assert_equal [6618611909121, "tail"],
- decode("\x83o\0\0\0\6\0\1\2\3\4\5\6tail")
- end
- def test_decode_compressed_term
- assert_raise(IncompleteData){decode("\x83P")}
- assert_raise(IncompleteData){decode("\x83P\0")}
- assert_raise(IncompleteData){decode("\x83P\0\0")}
- assert_raise(IncompleteData){decode("\x83P\0\0\0")}
- assert_raise(IncompleteData){decode("\x83P\0\0\0\0")}
- assert_raise(ValueError){decode("\x83P\0\0\0\x16" \
- "\x78\xda\xcb\x66\x10\x49\xc1\2\0\x5d\x60\x08\x50")}
- assert_equal [[100] * 20, ""], decode("\x83P\0\0\0\x17" \
- "\x78\xda\xcb\x66\x10\x49\xc1\2\0\x5d\x60\x08\x50")
- assert_equal [[100] * 20, "tail"], decode("\x83P\0\0\0\x17" \
- "\x78\xda\xcb\x66\x10\x49\xc1\2\0\x5d\x60\x08\x50tail")
- end
- end
- class EncodeTestCase < Test::Unit::TestCase
- def test_decode
- assert_equal "\x83h\0", encode(Tuple.new([]))
- assert_equal "\x83h\2h\0h\0",
- encode(Tuple.new([Tuple.new([]), Tuple.new([])]))
- assert_equal "\x83h\xff" + "h\0" * 255,
- encode(Tuple.new([Tuple.new([])] * 255))
- assert_equal "\x83i\0\0\1\0" + "h\0" * 256,
- encode(Tuple.new([Tuple.new([])] * 256))
- end
- def test_encode_empty_list
- assert_equal "\x83j", encode([])
- end
- def test_encode_string_list
- assert_equal "\x83k\0\1\0", encode([0])
- r = (0..255).to_a
- assert_equal "\x83k\1\0" + r.pack("C*"), encode(r)
- end
- def test_encode_list
- assert_equal "\x83l\0\0\0\1jj", encode([[]])
- assert_equal "\x83l\0\0\0\5jjjjjj", encode([[], [], [], [], []])
- end
- def test_encode_improper_list
- assert_equal "\x83l\0\0\0\1h\0h\0",
- encode(ImproperList.new([Tuple.new([])], Tuple.new([])))
- assert_equal "\x83l\0\0\0\1a\0a\1", encode(ImproperList.new([0], 1))
- end
- def test_encode_atom
- assert_equal "\x83d\0\0", encode(:"")
- assert_equal "\x83d\0\4test", encode(:test)
- assert_equal "\x83d\0\2\xd0\x90", encode([0x410].pack("U*").to_sym)
- end
- def test_encode_string
- assert_equal "\x83m\0\0\0\0", encode("")
- assert_equal "\x83m\0\0\0\4test", encode("test")
- assert_equal "\x83m\0\0\0\2\xd0\x90", encode([0x410].pack("U*"))
- end
- def test_encode_boolean
- assert_equal "\x83d\0\4true", encode(true)
- assert_equal "\x83d\0\5false", encode(false)
- end
- def test_encode_short_integer
- assert_equal "\x83a\0", encode(0)
- assert_equal "\x83a\xff", encode(255)
- end
- def test_encode_integer
- assert_equal "\x83b\xff\xff\xff\xff", encode(-1)
- assert_equal "\x83b\x80\0\0\0", encode(-2147483648)
- assert_equal "\x83b\0\0\1\0", encode(256)
- assert_equal "\x83b\x7f\xff\xff\xff", encode(2147483647)
- end
- def test_encode_long_integer
- assert_equal "\x83n\4\0\0\0\0\x80", encode(2147483648)
- assert_equal "\x83n\4\1\1\0\0\x80", encode(-2147483649)
- assert_equal "\x83o\0\0\1\0\0" + "\0" * 255 + "\1", encode(2 ** 2040)
- assert_equal "\x83o\0\0\1\0\1" + "\0" * 255 + "\1", encode(-2 ** 2040)
- end
- def test_encode_float
- assert_equal "\x83F\0\0\0\0\0\0\0\0", encode(0.0)
- assert_equal "\x83F?\xe0\0\0\0\0\0\0", encode(0.5)
- assert_equal "\x83F\xbf\xe0\0\0\0\0\0\0", encode(-0.5)
- assert_equal "\x83F@\t!\xfbM\x12\xd8J", encode(3.1415926)
- assert_equal "\x83F\xc0\t!\xfbM\x12\xd8J", encode(-3.1415926)
- end
- def test_encode_none
- assert_equal "\x83d\0\11undefined", encode(nil)
- end
- def test_encode_opaque_object
- assert_equal "\x83h\3d\0\x0f$erlport.opaqued\0\10language" \
- "m\0\0\0\4data", encode(OpaqueObject.new("data", \
- :language))
- assert_equal "\x83data",
- encode(OpaqueObject.new("data", :erlang))
- end
- def test_ruby_opaque_object
- assert_equal "\203h\003d\000\017$erlport.opaqued" \
- "\000\004rubym\000\000\000\004\004\b{\000", encode({})
- assert_raise(ValueError){encode(Module.new())}
- end
- def test_encode_compressed_term
- assert_equal "\x83l\x00\x00\x00\x05jjjjjj", encode([[]] * 5, true)
- assert_equal "\x83P\x00\x00\x00\x15" \
- "x\x9c\xcba``\xe0\xcfB\x03\x00B@\x07\x1c",
- encode([[]] * 15, true)
- assert_equal "\x83P\x00\x00\x00\x15" \
- "x\x9c\xcba``\xe0\xcfB\x03\x00B@\x07\x1c",
- encode([[]] * 15, 6)
- assert_equal "\x83P\x00\x00\x00\x15" \
- "x\xda\xcba``\xe0\xcfB\x03\x00B@\x07\x1c",
- encode([[]] * 15, 9)
- assert_equal "\x83l\0\0\0\x0f" + "j" * 15 + "j",
- encode([[]] * 15, 0)
- assert_equal "\x83P\x00\x00\x00\x15" \
- "x\x01\xcba``\xe0\xcfB\x03\x00B@\x07\x1c",
- encode([[]] * 15, 1)
- end
- end