rdf-spec 0.1.10 → 0.2.0

data/README

@@ -15,14 +15,14 @@ Documentation
 Dependencies
 ------------
 
-* [RDF.rb](http://gemcutter.org/gems/rdf) (>= 0.1.9)
+* [RDF.rb](http://gemcutter.org/gems/rdf) (>= 0.2.0)
 * [RSpec](http://gemcutter.org/gems/rspec) (>= 1.3.0)
 
 Installation
 ------------
 
-The recommended installation method is via RubyGems. To install the latest
-official release from Gemcutter, do:
+The recommended installation method is via [RubyGems](http://rubygems.org/).
+To install the latest official release of `RDF::Spec`, do:
 
     % [sudo] gem install rdf-spec
 

data/VERSION

@@ -1 +1 @@
-0.1.10
+0.2.0

data/etc/doap.nt

@@ -1,24 +1,47 @@
 <http://ar.to/#self> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
+<http://ar.to/#self> <http://www.w3.org/2000/01/rdf-schema#isDefinedBy> <http://datagraph.org/bendiken/foaf> .
+<http://ar.to/#self> <http://xmlns.com/foaf/0.1/homepage> <http://ar.to/> .
 <http://ar.to/#self> <http://xmlns.com/foaf/0.1/made> <http://rubygems.org/gems/rdf> .
 <http://ar.to/#self> <http://xmlns.com/foaf/0.1/mbox> <mailto:arto.bendiken@gmail.com> .
+<http://ar.to/#self> <http://xmlns.com/foaf/0.1/mbox_sha1sum> "a033f652c84a4d73b8c26d318c2395699dd2bdfb" .
+<http://ar.to/#self> <http://xmlns.com/foaf/0.1/mbox_sha1sum> "d0737cceb55eb7d740578d2db1bc0727e3ed49ce" .
 <http://ar.to/#self> <http://xmlns.com/foaf/0.1/name> "Arto Bendiken" .
 <http://bhuga.net/#ben> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
+<http://bhuga.net/#ben> <http://www.w3.org/2000/01/rdf-schema#isDefinedBy> <http://datagraph.org/bhuga/foaf> .
+<http://bhuga.net/#ben> <http://xmlns.com/foaf/0.1/homepage> <http://bhuga.net/> .
 <http://bhuga.net/#ben> <http://xmlns.com/foaf/0.1/mbox> <mailto:blavender@gmail.com> .
+<http://bhuga.net/#ben> <http://xmlns.com/foaf/0.1/mbox_sha1sum> "dbf45f4ffbd27b67aa84f02a6a31c144727d10af" .
 <http://bhuga.net/#ben> <http://xmlns.com/foaf/0.1/name> "Ben Lavender" .
 <http://rubygems.org/gems/rdf> <http://purl.org/dc/terms/creator> <http://ar.to/#self> .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#blog> <http://ar.to/> .
+<http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#blog> <http://blog.datagraph.org/> .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#bug-database> <http://github.com/bendiken/rdf/issues> .
+<http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#category> <http://dbpedia.org/resource/Resource_Description_Framework> .
+<http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#category> <http://dbpedia.org/resource/Ruby_(programming_language)> .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#created> "2007-10-23" .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#description> "RDF.rb is a pure-Ruby library for working with Resource Description Framework (RDF) data."@en .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#developer> <http://ar.to/#self> .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#developer> <http://bhuga.net/#ben> .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#documenter> <http://ar.to/#self> .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#download-page> <http://rubyforge.org/projects/rdf/> .
+<http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid1 .
+<http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid2 .
+<http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid3 .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#homepage> <http://rdf.rubyforge.org/> .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#license> <http://creativecommons.org/licenses/publicdomain/> .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#maintainer> <http://ar.to/#self> .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#name> "RDF.rb" .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#platform> "Ruby" .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#shortdesc> "A Ruby library for working with Resource Description Framework (RDF) data."@en .
+<http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#vendor> <http://datagraph.org/> .
 <http://rubygems.org/gems/rdf> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://usefulinc.com/ns/doap#Project> .
 <http://rubygems.org/gems/rdf> <http://xmlns.com/foaf/0.1/maker> <http://ar.to/#self> .
+_:genid1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
+_:genid1 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "c69f3255ff0639543cc5edfd8116eac8df16fab8" .
+_:genid1 <http://xmlns.com/foaf/0.1/name> "Hellekin O. Wolf" .
+_:genid2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
+_:genid2 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "f7653fc1ac0e82ebb32f092389bd5fc728eaae12" .
+_:genid2 <http://xmlns.com/foaf/0.1/name> "John Fieber" .
+_:genid3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
+_:genid3 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "bedbbf2451e5beb38d59687c0460032aff92cd3c" .
+_:genid3 <http://xmlns.com/foaf/0.1/name> "Pius Uzamere" .

data/lib/rdf/spec/countable.rb

@@ -0,0 +1,42 @@
+require 'rdf/spec'
+require 'spec'
+
+share_as :RDF_Countable do
+  include RDF::Spec::Matchers
+
+  before :each do
+    raise '+@countable+ must be defined in a before(:each) block' unless instance_variable_get('@countable')
+
+    @filename   = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
+    @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
+
+    if @countable.empty?
+      if @countable.respond_to?(:<<)
+        @statements.each { |statement| @countable << statement }
+      else
+        raise "+@countable+ must respond to #<< or be pre-populated with the statements in #{@filename} in a before(:each) block"
+      end
+    end
+  end
+
+  context "when counting items" do
+    it "should respond to #empty?" do
+      @countable.should respond_to(:empty?)
+    end
+
+    it "should respond to #count and #size" do
+      @countable.should respond_to(*%w(count size))
+    end
+
+    it "should implement #empty?" do
+      ([].extend(RDF::Countable)).empty?.should be_true
+      @countable.empty?.should be_false
+    end
+
+    it "should implement #count and #size" do
+      %w(count size).each do |method|
+        @countable.send(method).should == @statements.size
+      end
+    end
+  end
+end

data/lib/rdf/spec/enumerable.rb

@@ -6,131 +6,202 @@ share_as :RDF_Enumerable do
 
   before :each do
     raise '+@enumerable+ must be defined in a before(:each) block' unless instance_variable_get('@enumerable')
-    raise '+@statements+ must be defined in a before(:each) block' unless instance_variable_get('@statements')
-  end
 
-  it "should support #empty?" do
-    @enumerable.respond_to?(:empty?).should be_true
+    @filename   = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
+    @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
+
+    if @enumerable.empty?
+      if @enumerable.respond_to?(:<<)
+        @statements.each { |statement| @enumerable << statement }
+      else
+        raise "@enumerable must respond to #<< or be pre-populated with the statements in #{@filename} in a before(:each) block"
+      end
+    end
 
-    ([].extend(RDF::Enumerable)).empty?.should be_true
-    @enumerable.empty?.should be_false
+    # Assume contexts are supported unless declared otherwise:
+    @supports_context = @enumerable.respond_to?(:supports?) ? @enumerable.supports?(:context) : true
   end
 
-  it "should support #count and #size" do
-    [:count, :size, :length].each do |method|
-      @enumerable.respond_to?(method).should be_true
+  context "when counting statements" do
+    it "should respond to #empty?" do
+      @enumerable.should respond_to(:empty?)
+    end
+
+    it "should respond to #count and #size" do
+      @enumerable.should respond_to(*%w(count size length))
+    end
+
+    it "should implement #empty?" do
+      ([].extend(RDF::Enumerable)).empty?.should be_true
+      @enumerable.empty?.should be_false
+    end
 
-      @enumerable.send(method).should == @statements.size
+    it "should implement #count and #size" do
+      %w(count size length).each do |method|
+        @enumerable.send(method).should == @statements.size
+      end
     end
   end
 
-  context "statements" do
-    it "should support #statements" do
-      @enumerable.respond_to?(:statements).should be_true
+  context "when enumerating statements" do
+    it "should respond to #statements" do
+      @enumerable.should respond_to(:statements)
+    end
 
-      @enumerable.statements.should be_instance_of(Array)
-      @enumerable.statements.size.should == @statements.size
-      @enumerable.statements.each { |statement| statement.should be_a_statement }
+    it "should respond to #has_statement?" do
+      @enumerable.should respond_to(:has_statement?)
     end
 
-    it "should support #has_statement?" do
-      @enumerable.respond_to?(:has_statement?).should be_true
+    it "should respond to #each_statement" do
+      @enumerable.should respond_to(:each_statement)
+    end
+
+    it "should respond to #enum_statement" do
+      @enumerable.should respond_to(:enum_statement)
+    end
+
+    it "should implement #statements" do
+      @enumerable.statements.should be_an_enumerator
+      @enumerable.statements.to_a.size.should == @statements.size
+      @enumerable.statements.each { |statement| statement.should be_a_statement }
+    end
 
+    it "should implement #has_statement?" do
       @statements.each do |statement|
         @enumerable.has_statement?(statement).should be_true
       end
 
+      context = RDF::URI.new("urn:context:1")
+      @statements.each do |statement|
+        s = statement.dup
+        s.context = context
+        @enumerable.has_statement?(s).should be_false
+      end
+
       unknown_statement = RDF::Statement.new(RDF::Node.new, RDF::URI.new("http://example.org/unknown"), RDF::Node.new)
       @enumerable.has_statement?(unknown_statement).should be_false
     end
 
-    it "should support #each_statement" do
-      @enumerable.respond_to?(:each_statement).should be_true
-
-      @enumerable.each_statement.should be_instance_of(RDF::Enumerator)
+    it "should implement #each_statement" do
+      @enumerable.each_statement.should be_an_enumerator
       @enumerable.each_statement { |statement| statement.should be_a_statement }
     end
 
-    it "should support #enum_statement" do
-      @enumerable.respond_to?(:enum_statement).should be_true
-
-      @enumerable.enum_statement.should be_instance_of(RDF::Enumerator)
+    it "should implement #enum_statement" do
+      @enumerable.enum_statement.should be_an_enumerator
+      @enumerable.enum_statement.should be_countable
+      @enumerable.enum_statement.should be_enumerable
+      @enumerable.enum_statement.should be_queryable
+      @enumerable.enum_statement.to_a.should == @enumerable.each_statement.to_a
     end
   end
 
-  context "triples" do
-    it "should support #triples" do
-      @enumerable.respond_to?(:triples).should be_true
+  context "when enumerating triples" do
+    it "should respond to #triples" do
+      @enumerable.should respond_to(:triples)
+    end
 
-      @enumerable.triples.should be_instance_of(Array)
-      @enumerable.triples.size.should == @statements.size
-      @enumerable.triples.each { |triple| triple.should be_a_triple }
+    it "should respond to #has_triple?" do
+      @enumerable.should respond_to(:has_triple?)
+    end
+
+    it "should respond to #each_triple" do
+      @enumerable.should respond_to(:each_triple)
+    end
+
+    it "should respond to #enum_triple" do
+      @enumerable.should respond_to(:enum_triple)
     end
 
-    it "should support #has_triple?" do
-      @enumerable.respond_to?(:has_triple?).should be_true
+    it "should implement #triples" do
+      @enumerable.triples.should be_an_enumerator
+      @enumerable.triples.to_a.size.should == @statements.size
+      @enumerable.triples.each { |triple| triple.should be_a_triple }
+    end
 
+    it "should implement #has_triple?" do
       @statements.each do |statement|
         @enumerable.has_triple?(statement.to_triple).should be_true
       end
     end
 
-    it "should support #each_triple" do
-      @enumerable.respond_to?(:each_triple).should be_true
-
-      @enumerable.each_triple.should be_instance_of(RDF::Enumerator)
+    it "should implement #each_triple" do
+      @enumerable.each_triple.should be_an_enumerator
       @enumerable.each_triple { |*triple| triple.should be_a_triple }
     end
 
-    it "should support #enum_triple" do
-      @enumerable.respond_to?(:enum_triple).should be_true
-
-      @enumerable.enum_triple.should be_instance_of(RDF::Enumerator)
+    it "should implement #enum_triple" do
+      @enumerable.enum_triple.should be_an_enumerator
+      @enumerable.enum_triple.should be_countable
+      @enumerable.enum_triple.to_a.should == @enumerable.each_triple.to_a
     end
   end
 
-  context "quads" do
-    it "should support #quads" do
-      @enumerable.respond_to?(:quads).should be_true
+  context "when enumerating quads" do
+    it "should respond to #quads" do
+      @enumerable.should respond_to(:quads)
+    end
 
-      @enumerable.quads.should be_instance_of(Array)
-      @enumerable.quads.size.should == @statements.size
-      @enumerable.quads.each { |quad| quad.should be_a_quad }
+    it "should respond to #has_quad?" do
+      @enumerable.should respond_to(:has_quad?)
     end
 
-    it "should support #has_quad?" do
-      @enumerable.respond_to?(:has_quad?).should be_true
+    it "should respond to #each_quad" do
+      @enumerable.should respond_to(:each_quad)
+    end
+
+    it "should respond to #enum_quad" do
+      @enumerable.should respond_to(:enum_quad)
+    end
+
+    it "should implement #quads" do
+      @enumerable.quads.should be_an_enumerator
+      @enumerable.quads.to_a.size.should == @statements.size
+      @enumerable.quads.each { |quad| quad.should be_a_quad }
+    end
 
+    it "should implement #has_quad?" do
       @statements.each do |statement|
         @enumerable.has_quad?(statement.to_quad).should be_true
       end
     end
 
-    it "should support #each_quad" do
-      @enumerable.respond_to?(:each_quad).should be_true
-
-      @enumerable.each_quad.should be_instance_of(RDF::Enumerator)
+    it "should implement #each_quad" do
+      @enumerable.each_quad.should be_an_enumerator
       @enumerable.each_quad { |*quad| quad.should be_a_quad }
     end
 
-    it "should support #enum_quad" do
-      @enumerable.respond_to?(:enum_quad).should be_true
-
-      @enumerable.enum_quad.should be_instance_of(RDF::Enumerator)
+    it "should implement #enum_quad" do
+      @enumerable.enum_quad.should be_an_enumerator
+      @enumerable.enum_quad.should be_countable
+      @enumerable.enum_quad.to_a.should == @enumerable.each_quad.to_a
     end
   end
 
-  context "subjects" do
-    it "should support #subjects" do
-      @enumerable.respond_to?(:subjects).should be_true
+  context "when enumerating subjects" do
+    it "should respond to #subjects" do
+      @enumerable.should respond_to(:subjects)
+    end
 
-      @enumerable.subjects.should be_instance_of(Array)
-      @enumerable.subjects.each { |value| value.should be_a_resource }
+    it "should respond to #has_subject?" do
+      @enumerable.should respond_to(:has_subject?)
+    end
+
+    it "should respond to #each_subject" do
+      @enumerable.should respond_to(:each_subject)
+    end
+
+    it "should respond to #enum_subject" do
+      @enumerable.should respond_to(:enum_subject)
     end
 
-    it "should support #has_subject?" do
-      @enumerable.respond_to?(:has_subject?).should be_true
+    it "should implement #subjects" do
+      @enumerable.subjects.should be_an_enumerator
+      @enumerable.subjects.each { |value| value.should be_a_resource }
+      # TODO: subjects(:unique => false)
+    end
 
+    it "should implement #has_subject?" do
       checked = []
       @statements.each do |statement|
         @enumerable.has_subject?(statement.subject).should be_true unless checked.include?(statement.subject)
@@ -140,10 +211,8 @@ share_as :RDF_Enumerable do
       @enumerable.has_predicate?(uri).should be_false
     end
 
-    it "should support #each_subject" do
-      @enumerable.respond_to?(:each_subject).should be_true
-
-      @enumerable.each_subject.should be_instance_of(RDF::Enumerator)
+    it "should implement #each_subject" do
+      @enumerable.each_subject.should be_an_enumerator
       subjects = @statements.map { |s| s.subject }.uniq
       @enumerable.each_subject.to_a.size.should == subjects.size
       @enumerable.each_subject do |value|
@@ -152,24 +221,37 @@ share_as :RDF_Enumerable do
       end
     end
 
-    it "should support #enum_subject" do
-      @enumerable.respond_to?(:enum_subject).should be_true
-
-      @enumerable.enum_subject.should be_instance_of(RDF::Enumerator)
+    it "should implement #enum_subject" do
+      @enumerable.enum_subject.should be_an_enumerator
+      @enumerable.enum_subject.should be_countable
+      @enumerable.enum_subject.to_a.should == @enumerable.each_subject.to_a
     end
   end
 
-  context "predicates" do
-    it "should support #predicates" do
-      @enumerable.respond_to?(:predicates).should be_true
+  context "when enumerating predicates" do
+    it "should respond to #predicates" do
+      @enumerable.should respond_to(:predicates)
+    end
 
-      @enumerable.predicates.should be_instance_of(Array)
-      @enumerable.predicates.each { |value| value.should be_a_uri }
+    it "should respond to #has_predicate?" do
+      @enumerable.should respond_to(:has_predicate?)
     end
 
-    it "should support #has_predicate?" do
-      @enumerable.respond_to?(:has_predicate?).should be_true
+    it "should respond to #each_predicate" do
+      @enumerable.should respond_to(:each_predicate)
+    end
+
+    it "should respond to #enum_predicate" do
+      @enumerable.should respond_to(:enum_predicate)
+    end
 
+    it "should implement #predicates" do
+      @enumerable.predicates.should be_an_enumerator
+      @enumerable.predicates.each { |value| value.should be_a_uri }
+      # TODO: predicates(:unique => false)
+    end
+
+    it "should implement #has_predicate?" do
       checked = []
       @statements.each do |statement|
         @enumerable.has_predicate?(statement.predicate).should be_true unless checked.include?(statement.object)
@@ -179,36 +261,47 @@ share_as :RDF_Enumerable do
       @enumerable.has_predicate?(uri).should be_false
     end
 
-    it "should support #each_predicate" do
-      @enumerable.respond_to?(:each_predicate).should be_true
-
+    it "should implement #each_predicate" do
       predicates = @statements.map { |s| s.predicate }.uniq
+      @enumerable.each_predicate.should be_an_enumerator
       @enumerable.each_predicate.to_a.size.should == predicates.size
-      @enumerable.each_predicate.should be_instance_of(RDF::Enumerator)
-      @enumerable.each_predicate do |value| 
+      @enumerable.each_predicate do |value|
         value.should be_a_uri
         predicates.should include value
       end
     end
 
-    it "should support #enum_predicate" do
-      @enumerable.respond_to?(:enum_predicate).should be_true
-
-      @enumerable.enum_predicate.should be_instance_of(RDF::Enumerator)
+    it "should implement #enum_predicate" do
+      @enumerable.enum_predicate.should be_an_enumerator
+      @enumerable.enum_predicate.should be_countable
+      @enumerable.enum_predicate.to_a.should == @enumerable.each_predicate.to_a
     end
   end
 
-  context "objects" do
-    it "should support #objects" do
-      @enumerable.respond_to?(:objects).should be_true
+  context "when enumerating objects" do
+    it "should respond to #objects" do
+      @enumerable.should respond_to(:objects)
+    end
 
-      @enumerable.objects.should be_instance_of(Array)
-      @enumerable.objects.each { |value| value.should be_a_value }
+    it "should respond to #has_object?" do
+      @enumerable.should respond_to(:has_object?)
+    end
+
+    it "should respond to #each_object" do
+      @enumerable.should respond_to(:each_object)
+    end
+
+    it "should respond to #enum_object" do
+      @enumerable.should respond_to(:enum_object)
     end
 
-    it "should support #has_object?" do
-      @enumerable.respond_to?(:has_object?).should be_true
+    it "should implement #objects" do
+      @enumerable.objects.should be_an_enumerator
+      @enumerable.objects.each { |value| value.should be_a_value }
+      # TODO: objects(:unique => false)
+    end
 
+    it "should implement #has_object?" do
       checked = []
       @statements.each do |statement|
         @enumerable.has_object?(statement.object).should be_true unless checked.include?(statement.object)
@@ -218,36 +311,47 @@ share_as :RDF_Enumerable do
       @enumerable.has_object?(uri).should be_false
     end
 
-    it "should support #each_object" do
-      @enumerable.respond_to?(:each_object).should be_true
-
+    it "should implement #each_object" do
       objects = @statements.map { |s| s.object }.uniq
+      @enumerable.each_object.should be_an_enumerator
       @enumerable.each_object.to_a.size.should == objects.size
-      @enumerable.each_object.should be_instance_of(RDF::Enumerator)
-      @enumerable.each_object do |value| 
+      @enumerable.each_object do |value|
         value.should be_a_value
         objects.should include value
       end
     end
 
-    it "should support #enum_object" do
-      @enumerable.respond_to?(:enum_object).should be_true
-
-      @enumerable.enum_object.should be_instance_of(RDF::Enumerator)
+    it "should implement #enum_object" do
+      @enumerable.enum_object.should be_an_enumerator
+      @enumerable.enum_object.should be_countable
+      @enumerable.enum_object.to_a.should == @enumerable.each_object.to_a
     end
   end
 
-  context "contexts" do
-    it "should support #contexts" do
-      @enumerable.respond_to?(:contexts).should be_true
+  context "when enumerating contexts" do
+    it "should respond to #contexts" do
+      @enumerable.should respond_to(:contexts)
+    end
 
-      @enumerable.contexts.should be_instance_of(Array)
-      @enumerable.contexts.each { |value| value.should be_a_resource }
+    it "should respond to #has_context?" do
+      @enumerable.should respond_to(:has_context?)
     end
 
-    it "should support #has_context?" do
-      @enumerable.respond_to?(:has_context?).should be_true
+    it "should respond to #each_context" do
+      @enumerable.should respond_to(:each_context)
+    end
+
+    it "should respond to #enum_context" do
+      @enumerable.should respond_to(:enum_context)
+    end
+
+    it "should implement #contexts" do
+      @enumerable.contexts.should be_an_enumerator
+      @enumerable.contexts.each { |value| value.should be_a_resource }
+      # TODO: contexts(:unique => false)
+    end
 
+    it "should implement #has_context?" do
       @statements.each do |statement|
         if statement.has_context?
           @enumerable.has_context?(statement.context).should be_true
@@ -257,29 +361,54 @@ share_as :RDF_Enumerable do
       @enumerable.has_context?(uri).should be_false
     end
 
-    it "should support #each_context" do
-      @enumerable.respond_to?(:each_context).should be_true
-
+    it "should implement #each_context" do
       contexts = @statements.map { |s| s.context }.uniq
       contexts.delete nil
+      @enumerable.each_context.should be_an_enumerator
       @enumerable.each_context.to_a.size.should == contexts.size
-      @enumerable.each_context.should be_instance_of(RDF::Enumerator)
-      @enumerable.each_context do |value| 
-        value.should be_a_resource 
+      @enumerable.each_context do |value|
+        value.should be_a_resource
         contexts.should include value
       end
     end
 
-    it "should support #enum_context" do
-      @enumerable.respond_to?(:enum_context).should be_true
+    it "should implement #enum_context" do
+      @enumerable.enum_context.should be_an_enumerator
+      @enumerable.enum_context.should be_countable
+      @enumerable.enum_context.to_a.should == @enumerable.each_context.to_a
+    end
+  end
+
+  context "when enumerating graphs" do
+    it "should respond to #each_graph" do
+      @enumerable.should respond_to(:enum_graph)
+    end
 
-      @enumerable.enum_context.should be_instance_of(RDF::Enumerator)
+    it "should respond to #enum_graph" do
+      @enumerable.should respond_to(:enum_graph)
+    end
+
+    it "should implement #each_graph" do
+      @enumerable.each_graph.should be_an_enumerator
+      @enumerable.each_graph { |graph| graph.should be_a_graph }
+      # TODO: relying on #contexts, check that the returned values are correct.
+    end
+
+    it "should implement #enum_graph" do
+      @enumerable.enum_graph.should be_an_enumerator
+      @enumerable.enum_graph.should be_countable
+      @enumerable.enum_graph.to_a.should == @enumerable.each_graph.to_a
     end
   end
 
-  it "should support #to_hash" do
-    @enumerable.respond_to?(:to_hash).should be_true
+  context "when converting" do
+    it "should respond to #to_hash" do
+      @enumerable.should respond_to(:to_hash)
+    end
 
-    # TODO
+    it "should implement #to_hash" do
+      @enumerable.to_hash.should be_instance_of(Hash)
+      @enumerable.to_hash.keys.size.should == @enumerable.subjects.to_a.size
+    end
   end
 end