rltk 2.2.1 → 3.0.0

data/test/cg/tc_llvm.rb

@@ -0,0 +1,25 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/04
+# Description:	This file contains unit tests for rltk/cg/llvm.rb file.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/version'
+require 'rltk/cg/llvm'
+
+#######################
+# Classes and Modules #
+#######################
+
+class LLVMTester < Minitest::Test
+	def test_init
+		assert_raises(ArgumentError) { RLTK::CG::LLVM.init(:foo) }
+	end
+end

data/test/cg/tc_math.rb

@@ -0,0 +1,88 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/09
+# Description:	This file contains unit tests for various math instructions.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/llvm'
+require 'rltk/cg/module'
+require 'rltk/cg/execution_engine'
+require 'rltk/cg/type'
+require 'rltk/cg/value'
+
+#######################
+# Classes and Modules #
+#######################
+
+class MathTester < Minitest::Test	
+	def setup
+		RLTK::CG::LLVM.init(:X86)
+		
+		@mod = RLTK::CG::Module.new('Testing Module')
+		@jit = RLTK::CG::JITCompiler.new(@mod)
+	end
+	
+	def test_integer_binary_operations
+		int_binop_assert(:add,   3, 2,  3 + 2)
+		int_binop_assert(:sub,   3, 2,  3 - 2)
+		int_binop_assert(:mul,   3, 2,  3 * 2)
+		int_binop_assert(:udiv, 10, 2, 10 / 2)
+		int_binop_assert(:sdiv, 10, 2, 10 / 2)
+		int_binop_assert(:urem, 10, 3, 10 % 3)
+		int_binop_assert(:srem, 10, 3, 10 % 3)
+	end
+	
+	def test_integer_bitwise_binary_operations
+		int_binop_assert(:shl,   2, 3,  2 << 3)
+		int_binop_assert(:lshr, 16, 3, 16 >> 3)
+		int_binop_assert(:ashr, 16, 3, 16 >> 3)
+		int_binop_assert(:and,   2, 1,  2 & 1)
+		int_binop_assert(:or,    2, 1,  2 | 1)
+		int_binop_assert(:xor,   3, 2,  3 ^ 2)
+	end
+	
+	def test_float_binary_operations
+		float_binop_assert(:fadd, 3.1, 2.2, 3.1 + 2.2)
+		float_binop_assert(:fsub, 3.1, 2.2, 3.1 - 2.2)
+		float_binop_assert(:fmul, 3.1, 2.2, 3.1 * 2.2)
+		float_binop_assert(:fdiv, 3.1, 2.2, 3.1 / 2.2)
+		float_binop_assert(:frem, 3.1, 2.2, 3.1 % 2.2)
+	end
+	
+	def test_simple_math_fun
+		fun = @mod.functions.add('simple_math_tester', RLTK::CG::FloatType, [RLTK::CG::FloatType]) do |fun|
+			blocks.append do
+				ret(fadd(fun.params[0], RLTK::CG::Float.new(1.0)))
+			end
+		end
+		
+		assert_equal(6.0, @jit.run_function(fun, 5.0).to_f)
+	end
+	
+	##################
+	# Helper Methods #
+	##################
+	
+	def float_binop_assert(op, operand0, operand1, expected)
+		assert_in_delta(expected, run_binop(op, RLTK::CG::Float.new(operand0), RLTK::CG::Float.new(operand1), RLTK::CG::FloatType).to_f, 0.001)
+	end
+	
+	def int_binop_assert(op, operand0, operand1, expected)
+		assert_equal(expected, run_binop(op, RLTK::CG::NativeInt.new(operand0), RLTK::CG::NativeInt.new(operand1), RLTK::CG::NativeIntType).to_i)
+	end
+	
+	def run_binop(op, operand0, operand1, ret_type)
+		fun = @mod.functions.add(op.to_s + '_tester', ret_type, []) do
+			blocks.append { ret(self.send(op, operand0, operand1)) }
+		end
+		
+		@jit.run_function(fun)
+	end
+end

data/test/cg/tc_module.rb

@@ -0,0 +1,89 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/04
+# Description:	This file contains unit tests for the RLTK::CG::Module class.
+
+############
+# Requires #
+############
+
+# Standard Library
+require 'tempfile'
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/llvm'
+require 'rltk/cg/module'
+require 'rltk/cg/execution_engine'
+require 'rltk/cg/type'
+require 'rltk/cg/value'
+
+#######################
+# Classes and Modules #
+#######################
+
+class ModuleTester < Minitest::Test
+	def setup
+		RLTK::CG::LLVM.init(:X86)
+		
+		@mod = RLTK::CG::Module.new('Testing Module')
+		@jit = RLTK::CG::JITCompiler.new(@mod)
+		
+		@mod.functions.add('int_function_tester', RLTK::CG::NativeIntType, []) do
+			blocks.append { ret RLTK::CG::NativeInt.new(1) }
+		end
+	end
+	
+	def test_bitcode
+		Tempfile.open('bitcode') do |tmp|
+			assert(@mod.write_bitcode(tmp))
+			
+			new_mod = RLTK::CG::Module.read_bitcode(tmp.path)
+			new_jit = RLTK::CG::JITCompiler.new(new_mod)
+			
+			assert_equal(1, new_jit.run_function(new_mod.functions['int_function_tester']).to_i)
+		end
+	end
+	
+	def test_equality
+		mod0 = RLTK::CG::Module.new('foo')
+		mod1 = RLTK::CG::Module.new('bar')
+		mod2 = RLTK::CG::Module.new(mod0.ptr)
+		
+		assert_equal(mod0, mod2)
+		refute_equal(mod0, mod1)
+	end
+	
+	def test_external_fun
+		fun = @mod.functions.add(:sin, RLTK::CG::DoubleType, [RLTK::CG::DoubleType])
+		res = @jit.run_function(fun, RLTK::CG::GenericValue.new(1.0, RLTK::CG::DoubleType)).to_f(RLTK::CG::DoubleType)
+		
+		assert_in_delta(Math.sin(1.0), res, 1e-10)
+	end
+	
+	def test_simple_int_fun
+		assert_equal(1, @jit.run_function(@mod.functions['int_function_tester']).to_i)
+	end
+	
+	def test_simple_float_fun
+		fun = @mod.functions.add('float_function_tester', RLTK::CG::FloatType, []) do
+			blocks.append do
+				ret RLTK::CG::Float.new(1.5)
+			end
+		end
+		
+		assert_equal(1.5, @jit.run_function(fun).to_f(RLTK::CG::FloatType))
+	end
+	
+	def test_simple_double_fun
+		fun = @mod.functions.add('double_function_tester', RLTK::CG::DoubleType, []) do
+			blocks.append do
+				ret RLTK::CG::Double.new(1.6)
+			end
+		end
+		
+		assert_equal(1.6, @jit.run_function(fun).to_f(RLTK::CG::DoubleType))
+	end
+end

data/test/cg/tc_transforms.rb

@@ -0,0 +1,68 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/11
+# Description:	This file contains unit tests for the mechanics beind
+#			transformation passes.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/llvm'
+require 'rltk/cg/module'
+require 'rltk/cg/execution_engine'
+require 'rltk/cg/type'
+require 'rltk/cg/value'
+
+class TransformTester < Minitest::Test
+	def setup
+		RLTK::CG::LLVM.init(:X86)
+		
+		@mod = RLTK::CG::Module.new('Testing Module')
+		@jit = RLTK::CG::JITCompiler.new(@mod)
+	end
+	
+	def test_gdce
+		fn0 = @mod.functions.add('fn0', RLTK::CG::VoidType, []) do |fun|
+			fun.linkage = :internal
+			
+			blocks.append do
+				ret_void
+			end
+		end
+		
+		fn1 = @mod.functions.add('fn1', RLTK::CG::VoidType, []) do |fun|
+			fun.linkage = :internal
+			
+			blocks.append do
+				ret_void
+			end
+		end
+		
+		main = @mod.functions.add('main', RLTK::CG::VoidType, []) do
+			blocks.append do
+				call(fn0)
+				ret_void
+			end
+		end
+		
+		funs = @mod.functions.to_a
+		
+		assert(funs.include?(fn0))
+		assert(funs.include?(fn1))
+		assert(funs.include?(main))
+		
+		@mod.pass_manager << :GDCE
+		assert(@mod.pass_manager.run)
+		
+		funs = @mod.functions.to_a
+		
+		assert( funs.include?(fn0))
+		assert(!funs.include?(fn1))
+		assert( funs.include?(main))
+	end
+end

data/test/cg/tc_type.rb

@@ -0,0 +1,69 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/09
+# Description:	This file contains unit tests for the RLTK::CG::Type class and
+#			its subclasses.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/type'
+
+class TypeTester < Minitest::Test
+	def setup
+		@pointee = RLTK::CG::NativeIntType.instance
+		@pointer = RLTK::CG::PointerType.new(@pointee)
+	end
+	
+	def test_deferrent_element_type_stuct_type
+		type = RLTK::CG::StructType.new([], 'test_struct')
+		type.element_types = [RLTK::CG::NativeIntType, RLTK::CG::FloatType]
+		
+		assert_equal(2, type.element_types.size)
+		assert_equal(RLTK::CG::NativeIntType.instance, type.element_types[0])
+		assert_equal(RLTK::CG::FloatType.instance, type.element_types[1])
+		
+	end
+	
+	def test_element_type
+		assert_equal(@pointee, @pointer.element_type)
+	end
+	
+	def test_equality
+		assert_equal(RLTK::CG::NativeIntType, RLTK::CG::NativeIntType)
+		refute_equal(RLTK::CG::NativeIntType, RLTK::CG::FloatType)
+		
+		at0 = RLTK::CG::ArrayType.new(RLTK::CG::NativeIntType, 2)
+		at1 = RLTK::CG::ArrayType.new(RLTK::CG::NativeIntType, 2)
+		at2 = RLTK::CG::ArrayType.new(RLTK::CG::FloatType, 2)
+		
+		assert_equal(at0, at1)
+		refute_equal(at0, at2)
+	end
+	
+	def test_kind
+		assert_equal(:pointer, @pointer.kind)
+		assert_equal(:integer, @pointee.kind)
+	end
+	
+	def test_named_struct_type
+		type = RLTK::CG::StructType.new([RLTK::CG::NativeIntType, RLTK::CG::FloatType], 'test_struct')
+		
+		assert_instance_of(RLTK::CG::StructType, type)
+		assert_equal('test_struct', type.name)
+	end
+	
+	def test_simple_struct_type
+		type = RLTK::CG::StructType.new([RLTK::CG::NativeIntType, RLTK::CG::FloatType])
+		
+		assert_instance_of(RLTK::CG::StructType, type)
+		assert_equal(2, type.element_types.size)
+		assert_equal(RLTK::CG::NativeIntType.instance, type.element_types[0])
+		assert_equal(RLTK::CG::FloatType.instance, type.element_types[1])
+	end
+end

data/test/cg/tc_value.rb

@@ -0,0 +1,151 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/09
+# Description:	This file contains unit tests for the RLTK::CG::Value class and
+#			its subclasses.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/llvm'
+require 'rltk/cg/module'
+require 'rltk/cg/execution_engine'
+require 'rltk/cg/type'
+require 'rltk/cg/value'
+
+class ValueTester < Minitest::Test
+	def setup
+		RLTK::CG::LLVM.init(:X86)
+		
+		@mod = RLTK::CG::Module.new('Testing Module')
+		@jit = RLTK::CG::JITCompiler.new(@mod)
+	end
+	
+	def test_array_values
+		fun = @mod.functions.add('array_function_tester', RLTK::CG::NativeIntType,
+		                         [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType]) do |fun|
+		     
+			blocks.append do
+				ptr = alloca(RLTK::CG::ArrayType.new(RLTK::CG::NativeIntType, 2))
+			
+				array = load(ptr)
+				array = insert_value(array, fun.params[0], 0)
+				array = insert_value(array, fun.params[1], 1)
+			
+				ret(add(extract_value(array, 0), extract_value(array, 1)))
+			end
+		end
+		
+		assert_equal(5, @jit.run_function(fun, 2, 3).to_i)
+	end
+	
+	def test_constant_array_from_array
+		array = RLTK::CG::ConstantArray.new(RLTK::CG::NativeIntType, [RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(1)])
+		
+		assert_instance_of(RLTK::CG::ConstantArray, array)
+		assert_equal(2, array.length)
+	end
+	
+	def test_constant_array_from_size
+		array = RLTK::CG::ConstantArray.new(RLTK::CG::NativeIntType, 2) { |i| RLTK::CG::NativeInt.new(i) }
+		
+		assert_instance_of(RLTK::CG::ConstantArray, array)
+		assert_equal(2, array.length)
+	end
+	
+	def test_constant_vector_elements
+		fun = @mod.functions.add('constant_vector_elements_tester', RLTK::CG::NativeIntType,
+		                         [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType]) do |fun|
+			
+			blocks.append do
+				ptr = alloca(RLTK::CG::VectorType.new(RLTK::CG::NativeIntType, 2))
+				
+				vector = load(ptr)
+				vector = insert_element(vector, fun.params[0], RLTK::CG::NativeInt.new(0))
+				vector = insert_element(vector, fun.params[1], RLTK::CG::NativeInt.new(1))
+				
+				ret(add(extract_element(vector, RLTK::CG::NativeInt.new(0)), extract_element(vector, RLTK::CG::NativeInt.new(1))))
+			end
+		end
+		
+		assert_equal(5, @jit.run_function(fun, 2, 3).to_i)
+	end
+	
+	def test_constant_vector_from_array
+		vector = RLTK::CG::ConstantVector.new([RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(1)])
+		
+		assert_instance_of(RLTK::CG::ConstantVector, vector)
+		assert_equal(2, vector.size)
+	end
+	
+	def test_constant_vector_from_size
+		vector = RLTK::CG::ConstantVector.new(2) { |i| RLTK::CG::NativeInt.new(i) }
+		
+		assert_instance_of(RLTK::CG::ConstantVector, vector)
+		assert_equal(2, vector.size)
+	end
+	
+	def test_constant_vector_shuffle
+		fun = @mod.functions.add('constant_vector_shuffle_tester', RLTK::CG::NativeIntType, Array.new(4, RLTK::CG::NativeIntType)) do |fun|
+			blocks.append do
+				vec_type = RLTK::CG::VectorType.new(RLTK::CG::NativeIntType, 2)
+				
+				v0 = load(alloca(vec_type))
+				v0 = insert_element(v0, fun.params[0], RLTK::CG::NativeInt.new(0))
+				v0 = insert_element(v0, fun.params[1], RLTK::CG::NativeInt.new(1))
+				
+				v1 = load(alloca(vec_type))
+				v1 = insert_element(v1, fun.params[2], RLTK::CG::NativeInt.new(0))
+				v1 = insert_element(v1, fun.params[3], RLTK::CG::NativeInt.new(1))
+				
+				v2 = shuffle_vector(v0, v1, RLTK::CG::ConstantVector.new([RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(3)]))
+				
+				ret(add(extract_element(v2, RLTK::CG::NativeInt.new(0)), extract_element(v2, RLTK::CG::NativeInt.new(1))))
+			end
+		end
+		
+		assert_equal(5, @jit.run_function(fun, 1, 2, 3, 4).to_i)
+	end
+	
+	def test_constant_struct_from_size_packed
+		struct = RLTK::CG::ConstantStruct.new(2, true) { |i| RLTK::CG::NativeInt.new(i) }
+		
+		assert_instance_of(RLTK::CG::ConstantStruct, struct)
+		assert_equal(2, struct.operands.size)
+	end
+	
+	def test_constant_struct_from_size_unpacked
+		struct = RLTK::CG::ConstantStruct.new(2, false) { |i| RLTK::CG::NativeInt.new(i) }
+		
+		assert_instance_of(RLTK::CG::ConstantStruct, struct)
+		assert_equal(2, struct.operands.size)
+	end
+	
+	def test_constant_struct_from_values_packed
+		struct = RLTK::CG::ConstantStruct.new([RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(1)], true)
+		
+		assert_instance_of(RLTK::CG::ConstantStruct, struct)
+		assert_equal(2, struct.operands.size)
+	end
+	
+	def test_constant_struct_from_values_unpacked
+		struct = RLTK::CG::ConstantStruct.new([RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(1)], false)
+		
+		assert_instance_of(RLTK::CG::ConstantStruct, struct)
+		assert_equal(2, struct.operands.size)
+	end
+	
+	def test_equality
+		v0 = RLTK::CG::NativeInt.new(0)
+		v1 = RLTK::CG::NativeInt.new(1)
+		v2 = RLTK::CG::NativeInt.new(v0.ptr)
+		
+		assert_equal(v0, v2)
+		refute_equal(v0, v1)
+	end
+end

data/test/cg/ts_cg.rb

@@ -0,0 +1,23 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/04
+# Description:	This file contains test suit for the RLTK LLVM bindigns.  It
+#			requires the individual tests from their respective files.
+
+############
+# Requires #
+############
+
+# Ruby Language Toolkit
+require 'cg/tc_llvm'
+require 'cg/tc_module'
+
+require 'cg/tc_basic_block'
+require 'cg/tc_control_flow'
+require 'cg/tc_function'
+require 'cg/tc_generic_value'
+require 'cg/tc_instruction'
+require 'cg/tc_math'
+require 'cg/tc_transforms'
+require 'cg/tc_type'
+require 'cg/tc_value'

data/test/tc_ast.rb

@@ -7,9 +7,8 @@
 # Requires #
 ############
 
-# Standard Library
-require 'test/unit'
-require 'pp'
+# Gems
+require 'minitest/autorun'
 
 # Ruby Language Toolkit
 require 'rltk/ast'
@@ -18,7 +17,7 @@ require 'rltk/ast'
 # Classes and Modules #
 #######################
 
-class ASTNodeTester < Test::Unit::TestCase
+class ASTNodeTester < Minitest::Test
 	class ANode < RLTK::ASTNode
 		child :left, ANode
 		child :right, ANode
@@ -29,6 +28,14 @@ class ASTNodeTester < Test::Unit::TestCase
 
 	class DNode < RLTK::ASTNode; end
 	
+	class ENode < RLTK::ASTNode
+		value :str, String
+	end
+	
+	class FNode < ENode
+		child :c, [ENode]
+	end
+	
 	class SNode < RLTK::ASTNode
 		value :string, String
 		
@@ -36,6 +43,11 @@ class ASTNodeTester < Test::Unit::TestCase
 		child :right, SNode
 	end
 	
+	class VNode < RLTK::ASTNode
+		value :a, Integer
+		value :b, Integer
+	end
+	
 	def setup
 		@leaf0 = CNode.new
 		@tree0 = ANode.new(BNode.new(@leaf0), BNode.new)
@@ -60,6 +72,21 @@ class ASTNodeTester < Test::Unit::TestCase
 					)
 				)
 		
+		@tree5 = FNode.new('one',
+				[FNode.new('two',
+					[ENode.new('three')]),
+				ENode.new('four')])
+		
+		@tree6 = FNode.new('one',
+				[FNode.new('two',
+					[ENode.new('three')]),
+				ENode.new('four')])
+		
+		@tree7 = FNode.new('one!',
+				[FNode.new('two!',
+					[ENode.new('three!')]),
+				ENode.new('four!')])
+		
 		@bc_proc = Proc.new do |n|
 			case n
 			when BNode then	CNode.new(n.left, n.right)
@@ -77,6 +104,16 @@ class ASTNodeTester < Test::Unit::TestCase
 		node.children = (expected_children = [BNode.new, CNode.new])
 		
 		assert_equal(node.children, expected_children)
+		
+		node.children = (expected_children = {:left => CNode.new, :right => BNode.new})
+		
+		assert_equal(node.children(Hash), expected_children)
+	end
+	
+	def test_copy
+		new_tree = @tree5.copy
+		
+		assert_equal(@tree5, new_tree)
 	end
 	
 	def test_dump
@@ -108,16 +145,32 @@ class ASTNodeTester < Test::Unit::TestCase
 		@tree4.each(:level) { |n| nodes << n.string }
 		
 		assert_equal(expected, nodes)
+		
+		# Test iteration with array children.
+		
+		res	= ''
+		@tree5.each(:pre) { |node| res += ' ' + node.str }
+		assert_equal(res, ' one two three four')
+		
+		res	= ''
+		@tree5.each(:post) { |node| res += ' ' + node.str }
+		assert_equal(res, ' three two four one')
+		
+		res	= ''
+		@tree5.each(:level) { |node| res += ' ' + node.str }
+		assert_equal(res, ' one two four three')
 	end
 	
 	def test_equal
 		assert_equal(@tree0, @tree1)
-		assert_not_equal(@tree0, @tree2)
+		refute_equal(@tree0, @tree2)
 	end
 	
 	def test_initialize
-		assert_raise(RuntimeError) { RLTK::ASTNode.new }
-		assert_nothing_raised(RuntimeError) { ANode.new }
+		assert_raises(AbstractClassError) { RLTK::ASTNode.new }
+		
+		node = ENode.new { self.str = 'hello world' }
+		assert_equal('hello world', node.str)
 	end
 	
 	def test_map
@@ -125,19 +178,37 @@ class ASTNodeTester < Test::Unit::TestCase
 		
 		assert_equal(@tree0, @tree1)
 		assert_equal(@tree3, mapped_tree)
+		
+		mapped_tree = @tree5.map do |c|
+			c.str += '!'
+			
+			c
+		end
+		
+		assert_equal(@tree6, @tree5)
+		assert_equal(@tree7, mapped_tree)
 	end
 	
 	def test_map!
 		tree1_clone = @tree1.clone
 		tree1_clone.map!(&@bc_proc)
 		
-		assert_not_equal(@tree1, tree1_clone)
+		refute_equal(@tree1, tree1_clone)
 		assert_equal(@tree3, tree1_clone)
 		
 		replace_node = BNode.new
 		replace_node = replace_node.map!(&@bc_proc)
 		
 		assert_equal(CNode.new, replace_node)
+		
+		mapped_tree = @tree5.map! do |c|
+			c.str += '!'
+			
+			c
+		end
+		
+		refute_equal(@tree6, @tree5)
+		assert_equal(@tree7, @tree5)
 	end
 	
 	def test_notes
@@ -151,8 +222,34 @@ class ASTNodeTester < Test::Unit::TestCase
 		assert_nil(node[:a])
 	end
 	
+	def test_one_definition_rule
+		asserter = self
+		
+		Class.new(ANode) do
+			asserter.assert_raises(ArgumentError) { child :left, ANode }
+		end
+		
+		Class.new(ENode) do
+			asserter.assert_raises(ArgumentError) { value :str, String }
+		end
+	end
+	
 	def test_root
 		assert_same(@tree0, @tree0.root)
 		assert_same(@tree0, @leaf0.root)
 	end
+	
+	def test_value
+		node = VNode.new
+		
+		assert_equal(node.values, [nil, nil])
+		
+		node.values = (expected_values = [42, 1984])
+		
+		assert_equal(node.values, expected_values)
+		
+		node.values = (expected_values = {:a => 1984, :b => 42})
+		
+		assert_equal(node.values(Hash), expected_values)
+	end
 end