rubyrdf 0.0.1

data/test/test_namespace.rb

@@ -0,0 +1,130 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestNamespace < Test::Unit::TestCase
+  def setup
+    reset
+    RDF::Namespace.register(:ex, 'http://example.org/')
+  end
+  
+  def test_prefixes_should_return_array
+    assert RDF::Namespace.prefixes.is_a?(Array)
+  end
+  
+  def test_register_should_add_to_prefixes
+    reset
+    RDF::Namespace.register(:ex, 'http://example.org/')
+    assert RDF::Namespace.registered?(:ex)
+  end
+  
+  def test_register_should_raise_error_when_prefix_invalid
+    reset
+    assert_raise(ArgumentError) {
+      RDF::Namespace.register(nil, 'http://example.org/')
+    }
+  end
+  
+  def test_register_should_raise_error_when_base_invalid
+    reset
+    assert_raise(ArgumentError) {
+      RDF::Namespace.register(:ex, 'http://example.org')
+    }
+  end
+  
+  def test_register_should_not_raise_error_when_prefix_is_already_registered
+    reset
+    assert_nothing_raised {
+      RDF::Namespace.register(:ex, 'http://example.org/')
+      RDF::Namespace.register(:ex, 'http://example.org/')
+    }
+  end
+  
+  def test_register_should_create_module
+    reset
+    RDF::Namespace.register(:ex, 'http://example.org/')
+    assert Object.const_defined?(:EX)
+  end
+  
+  def test_register_should_find_module
+    reset
+    mod = Object.const_set(:EX, Module.new)
+    RDF::Namespace.register(:ex, 'http://example.org/')
+    assert mod.equal?(Object.const_get(:EX))
+  end
+  
+  def test_expand_should_return_uri
+    assert_equal 'http://example.org/Something', RDF::Namespace.expand(:ex, :Something)
+  end
+  
+  def test_split_should_return_base_and_name
+    assert_equal ['http://example.org/', 'Something'], RDF::Namespace.split('http://example.org/Something')
+  end
+  
+  def test_prefix_should_return_registered_prefix
+    assert_equal :ex, RDF::Namespace.prefix('http://example.org/Something')
+  end
+  
+  def test_method_missing_should_return_uri_node
+    assert_equal RDF::UriNode.new('http://example.org/something'), EX.something
+  end
+  
+  def test_const_missing_should_return_uri_node
+    assert_equal RDF::UriNode.new('http://example.org/Something'), EX::Something
+  end
+  
+  def test_method_missing_should_raise_error_with_arguments
+    assert_raise(ArgumentError) {
+      EX.something('test')
+    }
+  end
+  
+  def test_const_missing_should_raise_error_with_arguments
+    assert_raise(ArgumentError) {
+      EX::Something('test')
+    }
+  end
+  
+  def test_type_should_return_uri_node
+    assert_equal RDF::UriNode.new('http://example.org/type'), EX::type
+  end
+  
+  def test_name_should_return_uri_node
+    assert_equal RDF::UriNode.new('http://example.org/name'), EX::name
+  end
+  
+  def test_id_should_return_uri_node
+    assert_equal RDF::UriNode.new('http://example.org/id'), EX::id
+  end
+  
+  def test_should_automatically_define_rdf
+    assert_equal RDF::UriNode.new('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'), RDF::type
+  end
+  
+  def test_should_automatically_define_rdfs
+    assert_equal RDF::UriNode.new('http://www.w3.org/2000/01/rdf-schema#Class'), RDFS::Class
+  end
+  
+  def test_should_automatically_define_owl
+    assert_equal RDF::UriNode.new('http://www.w3.org/2002/07/owl#Thing'), OWL::Thing
+  end
+  
+  def test_should_automatically_define_xsd
+    assert_equal RDF::UriNode.new('http://www.w3.org/2001/XMLSchema#string'), XSD::string
+  end
+  
+  def test_registered_should_be_false_for_unregistered_namespace
+    assert !RDF::Namespace.registered?(:abc)
+  end
+  
+  def test_registered_should_be_true_for_registered_namespace
+    assert RDF::Namespace.registered?(:ex)
+  end
+  
+  private
+    def reset
+      RDF::Namespace.class_eval <<-ENDV
+        @@prefixes.delete(:ex) if @@prefixes.has_key?(:ex)
+        @@bases.delete('http://example.org/') if @@bases.has_key?('http://example.org/')
+      ENDV
+      Object.send(:remove_const, :EX) if Object.const_defined?(:EX)
+    end
+end

data/test/test_plain_literal_node.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestPlainLiteralNode < Test::Unit::TestCase
+  def test_new_should_initialize_lexical_form
+    assert_equal 'test', RDF::PlainLiteralNode.new('test', 'en').lexical_form
+  end
+  
+  def test_new_should_initialize_language_tag
+    assert_equal 'en', RDF::PlainLiteralNode.new('test', 'en').language_tag
+  end
+  
+  def test_new_should_default_language_tag_to_nil
+    assert_nil RDF::PlainLiteralNode.new('test').language_tag
+  end
+  
+  def test_equal_should_be_true_for_same_lexical_value
+    assert_equal RDF::PlainLiteralNode.new('test'), RDF::PlainLiteralNode.new('test')
+  end
+  
+  def test_equal_should_be_true_for_same_lexical_value_and_language_tag
+    assert_equal RDF::PlainLiteralNode.new('test', 'en'), RDF::PlainLiteralNode.new('test', 'en')
+  end
+  
+  def test_equal_should_be_true_for_same_lexical_value_and_different_case_language_tag
+    assert_equal RDF::PlainLiteralNode.new('test', 'en'), RDF::PlainLiteralNode.new('test', 'EN')
+  end
+  
+  def test_equal_should_be_false_for_same_lexical_value_and_different_language_tag
+    assert_not_equal RDF::PlainLiteralNode.new('test', 'en'), RDF::PlainLiteralNode.new('test', 'fr')
+  end
+  
+  def test_equal_should_be_false_for_same_lexical_value_and_missing_language_tag
+    assert_not_equal RDF::PlainLiteralNode.new('test', 'en'), RDF::PlainLiteralNode.new('test')
+  end
+  
+  def test_hash_should_be_equal_for_same_lexical_value
+    assert_equal RDF::PlainLiteralNode.new('test').hash, RDF::PlainLiteralNode.new('test').hash
+  end
+  
+  def test_hash_should_be_equal_for_same_lexical_value_and_language_tag
+    assert_equal RDF::PlainLiteralNode.new('test', 'en').hash, RDF::PlainLiteralNode.new('test', 'en').hash
+  end
+  
+  def test_hash_should_be_equal_for_same_lexical_value_and_different_case_language_tag
+    assert_equal RDF::PlainLiteralNode.new('test', 'en').hash, RDF::PlainLiteralNode.new('test', 'EN').hash
+  end
+  
+  def test_hash_should_not_be_equal_for_same_lexical_value_and_different_language_tag
+    assert_not_equal RDF::PlainLiteralNode.new('test', 'en').hash, RDF::PlainLiteralNode.new('test', 'fr').hash
+  end
+  
+  def test_hash_should_not_be_equal_for_same_lexical_value_and_missing_language_tag
+    assert_not_equal RDF::PlainLiteralNode.new('test', 'en').hash, RDF::PlainLiteralNode.new('test').hash
+  end
+  
+  def test_eql_should_be_true_for_same_lexical_value
+    assert RDF::PlainLiteralNode.new('test').eql?(RDF::PlainLiteralNode.new('test'))
+  end
+  
+  def test_eql_should_be_true_for_same_lexical_value_and_language_tag
+    assert RDF::PlainLiteralNode.new('test', 'en').eql?(RDF::PlainLiteralNode.new('test', 'en'))
+  end
+  
+  def test_eql_should_be_true_for_same_lexical_value_and_different_case_language_tag
+    assert RDF::PlainLiteralNode.new('test', 'en').eql?(RDF::PlainLiteralNode.new('test', 'EN'))
+  end
+  
+  def test_eql_should_be_false_for_same_lexical_value_and_different_language_tag
+    assert !RDF::PlainLiteralNode.new('test', 'en').eql?(RDF::PlainLiteralNode.new('test', 'fr'))
+  end
+  
+  def test_eql_should_be_false_for_same_lexical_value_and_missing_language_tag
+    assert !RDF::PlainLiteralNode.new('test', 'en').eql?(RDF::PlainLiteralNode.new('test'))
+  end
+  
+  def test_to_s_should_be_ntriples_format
+    assert_equal "\"test\"@en", RDF::PlainLiteralNode.new('test', 'en').to_s
+  end
+  
+  def test_to_s_should_be_not_include_nil_language_tag
+    assert_equal "\"test\"", RDF::PlainLiteralNode.new('test').to_s
+  end
+end

data/test/test_query.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestQuery < Test::Unit::TestCase
+  def setup
+    @graph = RDF::Graph::Memory.new
+  end
+  
+  def test_select_should_set_select_clause
+    query = RDF::Query.new
+    query.select(RDF::BlankNode.new('x', @graph), RDF::BlankNode.new('y', @graph))
+    assert_equal [RDF::BlankNode.new('x', @graph), RDF::BlankNode.new('y', @graph)], query.select_clause
+  end
+  
+  def test_select_should_return_self
+    query = RDF::Query.new
+    assert_equal query, query.select(RDF::BlankNode.new('x', @graph), RDF::BlankNode.new('y', @graph))
+  end
+  
+  def test_select_clause_should_clone
+    query = RDF::Query.new
+    query.select(RDF::BlankNode.new('x', @graph), RDF::BlankNode.new('y', @graph))
+    query.select_clause.clear
+    assert_equal [RDF::BlankNode.new('x', @graph), RDF::BlankNode.new('y', @graph)], query.select_clause
+  end
+  
+  def test_where_should_return_self
+    query = RDF::Query.new
+    assert_equal query, query.where(EX::a, EX::b, EX::c)
+  end
+  
+  def test_where_should_update_where_clause
+    query = RDF::Query.new
+    query.where(EX::a, EX::b, EX::c)
+    assert_equal [[EX::a, EX::b, EX::c]], query.where_clause
+  end
+  
+  def test_where_clause_should_clone
+    query = RDF::Query.new
+    query.where(EX::a, EX::b, EX::c)
+    query.where_clause.clear
+    assert_equal [[EX::a, EX::b, EX::c]], query.where_clause
+  end
+  
+  def test_and_should_alias_where
+    query = RDF::Query.new
+    query.and(EX::a, EX::b, EX::c)
+    assert_equal [[EX::a, EX::b, EX::c]], query.where_clause
+  end
+end

data/test/test_query_binding.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestQueryBinding < Test::Unit::TestCase
+  def test_new_should_initialize_hash
+    assert_equal EX::b, RDF::Query::Binding.new(EX::a => EX::b)[EX::a]
+  end
+  
+  def test_get_should_return_key_if_not_found
+    assert_equal EX::a, RDF::Query::Binding.new[EX::a]
+  end
+  
+  def test_set_should_assign_value_to_key
+    m = RDF::Query::Binding.new
+    m[EX::a] = EX::b
+    assert_equal EX::b, m[EX::a]
+  end
+  
+  def test_clone_should_perform_deep_copy
+    ma = RDF::Query::Binding.new
+    mb = ma.clone
+    ma[EX::a] = EX::b
+    assert !mb.bound?(EX::a)
+  end
+  
+  def test_bound_should_be_true
+    m = RDF::Query::Binding.new
+    m[EX::a] = EX::b
+    assert m.bound?(EX::a)
+  end
+  
+  def test_bound_should_be_false
+    m = RDF::Query::Binding.new
+    assert !m.bound?(EX::a)
+  end
+  
+  def test_equal_should_be_true_for_same_keys_and_values
+    assert_equal RDF::Query::Binding.new(EX::a => EX::b), RDF::Query::Binding.new(EX::a => EX::b)
+  end
+  
+  def test_equal_should_be_false_for_same_keys_and_different_values
+    assert_not_equal RDF::Query::Binding.new(EX::a => EX::b), RDF::Query::Binding.new(EX::a => EX::c)
+  end
+  
+  def test_equal_should_be_false_for_different_keys_and_same_values
+    assert_not_equal RDF::Query::Binding.new(EX::a => EX::b), RDF::Query::Binding.new(EX::c => EX::b)
+  end
+  
+  def test_eql_should_be_true_for_same_keys_and_values
+    assert RDF::Query::Binding.new(EX::a => EX::b).eql?(RDF::Query::Binding.new(EX::a => EX::b))
+  end
+  
+  def test_eql_should_be_false_for_same_keys_and_different_values
+    assert !RDF::Query::Binding.new(EX::a => EX::b).eql?(RDF::Query::Binding.new(EX::a => EX::c))
+  end
+  
+  def test_eql_should_be_false_for_different_keys_and_same_values
+    assert !RDF::Query::Binding.new(EX::a => EX::b).eql?(RDF::Query::Binding.new(EX::c => EX::b))
+  end
+  
+  def test_hash_should_be_equal_for_same_keys_and_values
+    assert_equal RDF::Query::Binding.new(EX::a => EX::b).hash, RDF::Query::Binding.new(EX::a => EX::b).hash
+  end
+  
+  def test_hash_should_not_be_equal_for_same_keys_and_different_values
+    assert_not_equal RDF::Query::Binding.new(EX::a => EX::b).hash, RDF::Query::Binding.new(EX::a => EX::c).hash
+  end
+  
+  def test_hash_should_not_be_equal_for_different_keys_and_same_values
+    assert_not_equal RDF::Query::Binding.new(EX::a => EX::b).hash, RDF::Query::Binding.new(EX::c => EX::b).hash
+  end
+  
+  def test_empty_should_be_true
+    assert RDF::Query::Binding.new.empty?
+  end
+  
+  def test_empty_should_be_false
+    assert !RDF::Query::Binding.new(EX::a => EX::b).empty?
+  end
+  
+  def test_to_s_should_show_hash_table
+    binding = RDF::Query::Binding.new(EX::a => EX::b)
+    assert_equal "{#{EX::a} => #{EX::b}}", binding.to_s
+  end
+end

data/test/test_query_result.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestQueryResult < Test::Unit::TestCase
+  def test_success_should_be_false
+    assert !RDF::Query::Result.new.success?
+  end
+  
+  def test_failure_should_be_true
+    assert RDF::Query::Result.new.failure?
+  end
+  
+  def test_bindings_should_return_set
+    assert RDF::Query::Result.new.bindings.is_a?(Set)
+  end
+  
+  def test_new_should_initialize_bindings
+    binding = RDF::Query::Binding.new(EX::a => EX::b)
+    assert RDF::Query::Result.new(binding).bindings.include?(binding)
+  end
+  
+  def test_new_should_initialize_bindings_from_params
+    binding1 = RDF::Query::Binding.new(EX::a => EX::b)
+    binding2 = RDF::Query::Binding.new(EX::b => EX::c)
+    result = RDF::Query::Result.new(binding1, binding2)
+    assert result.bindings.include?(binding1)
+    assert result.bindings.include?(binding2)
+  end
+  
+  def test_new_should_initialize_bindings_from_array
+    binding1 = RDF::Query::Binding.new(EX::a => EX::b)
+    binding2 = RDF::Query::Binding.new(EX::b => EX::c)
+    result = RDF::Query::Result.new([binding1, binding2])
+    assert result.bindings.include?(binding1)
+    assert result.bindings.include?(binding2)
+  end
+  
+  def test_success_bang_should_set_success
+    result = RDF::Query::Result.new
+    result.success!
+    assert result.success?
+  end
+  
+  def test_success_bang_should_create_result_and_set_success
+    assert RDF::Query::Result.success!.success?
+  end
+  
+  def test_success_bang_should_initialize_bindings
+    binding = RDF::Query::Binding.new(EX::a => EX::b)
+    assert RDF::Query::Result.success!(binding).bindings.include?(binding)
+  end
+  
+  def test_inject_should_raise_error_if_not_result
+    assert_raise(ArgumentError) {
+      RDF::Query::Result.new << 'test'
+    }
+  end
+  
+  def test_inject_should_ignore_bindings_for_failure
+    result = RDF::Query::Result.new(RDF::Query::Binding.new(EX::a => EX::b))
+    failed_binding = RDF::Query::Binding.new(EX::c => EX::d)
+    result << RDF::Query::Result.new(failed_binding)
+    
+    assert !result.bindings.include?(failed_binding)
+  end
+  
+  def test_inject_should_insert_bindings_for_success
+    result = RDF::Query::Result.new(RDF::Query::Binding.new(EX::a => EX::b))
+    binding = RDF::Query::Binding.new(EX::c => EX::d)
+    result << RDF::Query::Result.success!(binding)
+    
+    assert result.bindings.include?(binding)
+  end
+  
+  def test_inject_should_change_to_success
+    result = RDF::Query::Result.new(RDF::Query::Binding.new(EX::a => EX::b))
+    binding = RDF::Query::Binding.new(EX::c => EX::d)
+    result << RDF::Query::Result.success!(binding)
+    
+    assert result.success?
+  end
+  
+  def test_inject_should_discard_old_values_if_it_was_failed
+    binding = RDF::Query::Binding.new(EX::a => EX::b)
+    result = RDF::Query::Result.new(binding)
+    result << RDF::Query::Result.success!(RDF::Query::Binding.new(EX::c => EX::d))
+    
+    assert !result.bindings.include?(binding)
+  end
+  
+  def test_inject_should_keep_old_values_if_it_was_success
+    binding = RDF::Query::Binding.new(EX::a => EX::b)
+    result = RDF::Query::Result.success!(binding)
+    result << RDF::Query::Result.success!(RDF::Query::Binding.new(EX::c => EX::d))
+    
+    assert result.bindings.include?(binding)
+  end
+  
+  def test_inject_should_ignore_empty_bindings
+    result = RDF::Query::Result.success!
+    result << RDF::Query::Result.success!(RDF::Query::Binding.new({}))
+    
+    assert result.bindings.empty?
+  end
+  
+  def test_to_s_should_be_concatenation_of_bindings
+    result = RDF::Query::Result.success!(RDF::Query::Binding.new(EX::a => EX::b),
+      RDF::Query::Binding.new(EX::a => EX::c))
+    assert_equal "{#{result.bindings.collect{|b| b.to_s}.join(", ")}}", 
+      result.to_s
+  end
+end

data/test/test_rdf.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestRDF < Test::Unit::TestCase
+  def test_plain_literal_node_should_be_true_for_plain_literal_node
+    assert RDF::PlainLiteralNode?(RDF::PlainLiteralNode.new('test'))
+  end
+  
+  def test_plain_literal_node_should_be_true_for_duck_type
+    assert RDF::PlainLiteralNode?(Struct.new(:lexical_form, :language_tag).new)
+  end
+  
+  def test_typed_literal_node_should_be_true_for_typed_literal_node
+    assert RDF::TypedLiteralNode?(RDF::TypedLiteralNode.new('test', EX::a))
+  end
+  
+  def test_typed_literal_node_should_be_true_for_duck_type
+    assert RDF::TypedLiteralNode?(Struct.new(:lexical_form, :datatype_uri).new)
+  end
+  
+  def test_literal_node_should_check_both_plain_and_typed_literal_node
+    RDF.expects(:PlainLiteralNode?).returns(false)
+    RDF.expects(:TypedLiteralNode?).returns(false)
+    assert !RDF::LiteralNode?(RDF::PlainLiteralNode.new('test'))
+  end
+  
+  def test_uri_node_should_be_true_for_uri_node
+    assert RDF::UriNode?(RDF::UriNode.new(EX::a))
+  end
+  
+  def test_uri_node_should_be_true_for_duck_type
+    assert RDF::UriNode?(Struct.new(:uri).new)
+  end
+  
+  def test_blank_node_should_be_true_for_blank_node
+    assert RDF::BlankNode?(RDF::BlankNode.new(RDF::Graph::Memory.new, 'test'))
+  end
+  
+  def test_blank_node_should_be_true_for_duck_type
+    assert RDF::BlankNode?(Struct.new(:graph, :name).new)
+  end
+  
+  def test_node_should_check_literal_node_blank_node_and_uri_node
+    RDF.expects(:LiteralNode?).returns(false)
+    RDF.expects(:BlankNode?).returns(false)
+    RDF.expects(:UriNode?).returns(false)
+    assert !RDF::Node?(RDF::PlainLiteralNode.new('test'))
+  end
+  
+  def test_triple_should_be_true_for_triple
+    assert RDF::Triple?(RDF::Triple.new(EX::a, EX::b, EX::c))
+  end
+  
+  def test_triple_should_be_true_for_duck_type
+    assert RDF::Triple?(Struct.new(:subject, :predicate, :object).new)
+  end
+end

data/test/test_triple.rb

@@ -0,0 +1,147 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestTriple < Test::Unit::TestCase
+  def test_construct_should_return_triple
+    t = RDF::Triple.new(EX::a, EX::b, EX::c)
+    assert_same t, RDF::Triple.construct(t)
+  end
+  
+  def test_construct_should_return_nil_when_not_triple
+    assert_nil RDF::Triple.construct("test")
+  end
+  
+  def test_construct_should_create_triple
+    assert_equal RDF::Triple.new(EX::a, EX::b, EX::c), RDF::Triple.construct(EX::a, EX::b, EX::c)
+  end
+  
+  def test_construct_should_raise_argument_error_with_two_params
+    assert_raises(ArgumentError) do
+      RDF::Triple.construct(EX::a, EX::b)
+    end
+  end
+  
+  def test_construct_should_raise_argument_error_with_four_params
+    assert_raises(ArgumentError) do
+      RDF::Triple.construct(EX::a, EX::b, EX::c, EX::d)
+    end
+  end
+  
+  def test_new_should_initialize_subject
+    assert_equal EX::a, RDF::Triple.new(EX::a, EX::b, EX::c).subject
+  end
+  
+  def test_new_should_raise_error_for_nil_subject
+    assert_raise(ArgumentError) {
+      RDF::Triple.new(nil, EX::b, EX::c)
+    }
+  end
+  
+  def test_new_should_raise_error_for_non_node_subject
+    assert_raise(ArgumentError) {
+      RDF::Triple.new(:a, EX::b, EX::c)
+    }
+  end
+  
+  def test_new_should_raise_error_for_invalid_subject
+    assert_raise(RDF::InvalidSubjectError) {
+      RDF::Triple.new(RDF::PlainLiteralNode.new("test"), EX::b, EX::c)
+    }
+  end
+  
+  def test_new_should_initialize_predicate
+    assert_equal EX::b, RDF::Triple.new(EX::a, EX::b, EX::c).predicate
+  end
+  
+  def test_new_should_raise_error_for_nil_predicate
+    assert_raise(ArgumentError) {
+      RDF::Triple.new(EX::a, nil, EX::c)
+    }
+  end
+  
+  def test_new_should_raise_error_for_non_node_predicate
+    assert_raise(ArgumentError) {
+      RDF::Triple.new(EX::a, :a, EX::c)
+    }
+  end
+  
+  def test_new_should_raise_error_for_literal_node_predicate
+    assert_raise(RDF::InvalidPredicateError) {
+      RDF::Triple.new(EX::a, RDF::PlainLiteralNode.new('test'), EX::c)
+    }
+  end
+  
+  def test_new_should_raise_error_for_blank_node_predicate
+    assert_raise(RDF::InvalidPredicateError) {
+      RDF::Triple.new(EX::a, RDF::Graph::Memory.new.new_blank_node('x'), EX::c)
+    }
+  end
+  
+  def test_new_should_initialize_object
+    assert_equal EX::c, RDF::Triple.new(EX::a, EX::b, EX::c).object
+  end
+  
+  def test_new_should_raise_error_for_nil_object
+    assert_raise(ArgumentError) {
+      RDF::Triple.new(EX::a, EX::b, nil)
+    }
+  end
+  
+  def test_new_should_raise_error_for_non_node_object
+    assert_raise(ArgumentError) {
+      RDF::Triple.new(EX::a, EX::b, :a)
+    }
+  end
+  
+  def test_equal_should_be_true_for_same_subject_predicate_and_object
+    assert_equal RDF::Triple.new(EX::a, EX::b, EX::c), RDF::Triple.new(EX::a, EX::b, EX::c)
+  end
+  
+  def test_equal_should_be_false_for_same_predicate_object_but_different_subject
+    assert_not_equal RDF::Triple.new(EX::a, EX::b, EX::c), RDF::Triple.new(EX::d, EX::b, EX::c)
+  end
+  
+  def test_equal_should_be_false_for_same_subject_object_but_different_predicate
+    assert_not_equal RDF::Triple.new(EX::a, EX::b, EX::c), RDF::Triple.new(EX::a, EX::d, EX::c)
+  end
+  
+  def test_equal_should_be_false_for_same_subject_predicate_but_different_object
+    assert_not_equal RDF::Triple.new(EX::a, EX::b, EX::c), RDF::Triple.new(EX::a, EX::b, EX::d)
+  end
+  
+  def test_hash_should_be_equal_for_same_subject_predicate_and_object
+    assert_equal RDF::Triple.new(EX::a, EX::b, EX::c).hash, RDF::Triple.new(EX::a, EX::b, EX::c).hash
+  end
+  
+  def test_hash_should_not_be_equal_for_same_predicate_object_but_different_subject
+    assert_not_equal RDF::Triple.new(EX::a, EX::b, EX::c).hash, RDF::Triple.new(EX::d, EX::b, EX::c).hash
+  end
+  
+  def test_hash_should_not_be_equal_for_same_subject_object_but_different_predicate
+    assert_not_equal RDF::Triple.new(EX::a, EX::b, EX::c).hash, RDF::Triple.new(EX::a, EX::d, EX::c).hash
+  end
+  
+  def test_hash_should_not_be_equal_for_same_subject_predicate_but_different_object
+    assert_not_equal RDF::Triple.new(EX::a, EX::b, EX::c).hash, RDF::Triple.new(EX::a, EX::b, EX::d).hash
+  end
+  
+  def test_eql_should_be_true_for_same_subject_predicate_and_object
+    assert RDF::Triple.new(EX::a, EX::b, EX::c).eql?(RDF::Triple.new(EX::a, EX::b, EX::c))
+  end
+  
+  def test_eql_should_be_false_for_same_predicate_object_but_different_subject
+    assert !RDF::Triple.new(EX::a, EX::b, EX::c).eql?(RDF::Triple.new(EX::d, EX::b, EX::c))
+  end
+  
+  def test_eql_should_be_false_for_same_subject_object_but_different_predicate
+    assert !RDF::Triple.new(EX::a, EX::b, EX::c).eql?(RDF::Triple.new(EX::a, EX::d, EX::c))
+  end
+  
+  def test_eql_should_be_false_for_same_subject_predicate_but_different_object
+    assert !RDF::Triple.new(EX::a, EX::b, EX::c).eql?(RDF::Triple.new(EX::a, EX::b, EX::d))
+  end
+  
+  def test_to_s_should_be_ntriples_format
+    assert_equal "<http://example.org/a> <http://example.org/b> <http://example.org/c>.",
+      RDF::Triple.new(EX::a, EX::b, EX::c).to_s
+  end
+end