rdf_context 0.4.8 → 0.5.0

data/spec/literal_spec.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe "Literals: " do
@@ -15,14 +16,23 @@ describe "Literals: " do
     
     describe "should handle specific cases" do
       {
-        '"Gregg"' => Literal.untyped("Gregg"),
+        '"Gregg"'                     => Literal.untyped("Gregg"),
         '"\u677E\u672C \u540E\u5B50"' => Literal.untyped("松本 后子"),
-        '"D\u00FCrst"' => Literal.untyped("Dürst")
+        '"D\u00FCrst"'                => Literal.untyped("Dürst"),
       }.each_pair do |encoded, literal|
         it "should encode '#{literal.contents}'" do
           literal.to_n3.should == encoded
         end
       end
+
+      # Ruby 1.9 only
+      {
+         '"\U00015678another"'         => Literal.untyped("\u{15678}another"),
+       }.each_pair do |encoded, literal|
+         it "should encode '#{literal.contents}'" do
+           literal.to_n3.should == encoded
+         end
+       end if defined?(::Encoding)
     end
 
     describe "encodings" do
@@ -119,8 +129,6 @@ describe "Literals: " do
 
     it "should have string contents" do subject.contents.should == "true" end
     it "should have native contents" do subject.to_native.should == true end
-    it "should coerce 1" do Literal.typed("1", XSD_NS.boolean).contents.should == "true" end
-    it "should coerce 1" do Literal.typed("0", XSD_NS.boolean).contents.should == "false" end
   end
     
   describe "an integer" do
@@ -392,6 +400,101 @@ describe "Literals: " do
     end
   end
   
+  describe "valid content" do
+    {
+      "true"  => %("true"^^<http://www.w3.org/2001/XMLSchema#boolean>),
+      "false" => %("false"^^<http://www.w3.org/2001/XMLSchema#boolean>),
+      "tRuE"  => %("true"^^<http://www.w3.org/2001/XMLSchema#boolean>),
+      "FaLsE" => %("false"^^<http://www.w3.org/2001/XMLSchema#boolean>),
+      "1"     => %("true"^^<http://www.w3.org/2001/XMLSchema#boolean>),
+      "0"     => %("false"^^<http://www.w3.org/2001/XMLSchema#boolean>),
+    }.each_pair do |lit, n3|
+      it "should validate boolean '#{lit}'" do
+        Literal.typed(lit, XSD_NS.boolean).valid?.should be_true
+      end
+
+      it "should canonicalize boolean '#{lit}'" do
+        Literal.typed(lit, XSD_NS.boolean).to_ntriples.should == n3
+      end
+    end
+
+    {
+      "01" => %("1"^^<http://www.w3.org/2001/XMLSchema#integer>),
+      "1"  => %("1"^^<http://www.w3.org/2001/XMLSchema#integer>),
+      "-1" => %("-1"^^<http://www.w3.org/2001/XMLSchema#integer>),
+      "+1" => %("1"^^<http://www.w3.org/2001/XMLSchema#integer>),
+    }.each_pair do |lit, n3|
+      it "should validate integer '#{lit}'" do
+        Literal.typed(lit, XSD_NS.integer).valid?.should be_true
+      end
+
+      it "should canonicalize integer '#{lit}'" do
+        Literal.typed(lit, XSD_NS.integer).to_ntriples.should == n3
+      end
+    end
+
+    {
+      "1"                              => %("1.0"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "-1"                             => %("-1.0"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "1."                             => %("1.0"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "1.0"                            => %("1.0"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "1.00"                           => %("1.0"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "+001.00"                        => %("1.0"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "123.456"                        => %("123.456"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "2.345"                          => %("2.345"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "1.000000000"                    => %("1.0"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "2.3"                            => %("2.3"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "2.234000005"                    => %("2.234000005"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "2.2340000000000005"             => %("2.2340000000000005"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "2.23400000000000005"            => %("2.234"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "2.23400000000000000000005"      => %("2.234"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+      "1.2345678901234567890123457890" => %("1.2345678901234567"^^<http://www.w3.org/2001/XMLSchema#decimal>),
+    }.each_pair do |lit, n3|
+      it "should validate decimal '#{lit}'" do
+        Literal.typed(lit, XSD_NS.decimal).valid?.should be_true
+      end
+
+      it "should canonicalize decimal '#{lit}'" do
+        Literal.typed(lit, XSD_NS.decimal).to_ntriples.should == n3
+      end
+    end
+    
+    {
+      "1"         => %("1.0E0"^^<http://www.w3.org/2001/XMLSchema#double>),
+      "-1"        => %("-1.0E0"^^<http://www.w3.org/2001/XMLSchema#double>),
+      "+01.000"   => %("1.0E0"^^<http://www.w3.org/2001/XMLSchema#double>),
+      "1."        => %("1.0E0"^^<http://www.w3.org/2001/XMLSchema#double>),
+      "1.0"       => %("1.0E0"^^<http://www.w3.org/2001/XMLSchema#double>),
+      "123.456"   => %("1.23456E2"^^<http://www.w3.org/2001/XMLSchema#double>),
+      "1.0e+1"    => %("1.0E1"^^<http://www.w3.org/2001/XMLSchema#double>),
+      "1.0e-10"   => %("1.0E-10"^^<http://www.w3.org/2001/XMLSchema#double>),
+      "123.456e4" => %("1.23456E6"^^<http://www.w3.org/2001/XMLSchema#double>),
+    }.each_pair do |lit, n3|
+      it "should validate double '#{lit}'" do
+        Literal.typed(lit, XSD_NS.double).valid?.should be_true
+      end
+
+      it "should canonicalize double '#{lit}'" do
+        Literal.typed(lit, XSD_NS.double).to_ntriples.should == n3
+      end
+    end
+  end
+  
+  describe "invalid content" do
+    [
+      Literal.typed("foo", XSD_NS.boolean),
+      Literal.typed("xyz", XSD_NS.integer),
+      Literal.typed("12xyz", XSD_NS.integer),
+      Literal.typed("12.xyz", XSD_NS.decimal),
+      Literal.typed("xy.z", XSD_NS.double),
+      Literal.typed("+1.0z", XSD_NS.double),
+    ].each do |lit|
+      it "should detect invalid encoding for '#{lit.to_n3}'" do
+        lit.valid?.should be_false
+      end
+    end
+  end
+
   describe "Encodings" do
     specify "integer" do
       Literal::Encoding.integer.should == Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#int")
@@ -415,5 +518,4 @@ describe "Literals: " do
       Literal::Encoding.the_null_encoding.should == Literal::Null.new(nil)
     end
   end
-  
 end

data/spec/matchers.rb

@@ -1,19 +1,64 @@
-require 'rdf/redland'
-
 module Matchers
   class BeEquivalentGraph
+    Info = Struct.new(:about, :information, :trace, :compare, :inputDocument, :outputDocument)
     def normalize(graph)
-      case graph
-      when Graph then graph
-      when Parser then graph.graph
+      case @info.compare
+      when :array
+        array = case graph
+        when Graph, Parser
+          graph = graph.graph if graph.respond_to?(:graph)
+          anon = "a"
+          anon_ctx = {}
+          graph.triples.collect {|triple| triple.to_ntriples }.each do |t|
+            t.gsub(/_:nbn\d+[a-z]+N/, "_:").
+            gsub!(/_:bn\d+[a-z]+/) do |bn|
+              # Normalize anon BNodes
+              if anon_ctx[bn]
+                anon_ctx[bn]
+              else
+                anon_ctx[bn] = anon
+                anon = anon.succ
+              end
+              "_:#{anon_ctx[bn]}"
+            end
+          end.sort
+        when Array
+          graph.sort
+        else
+          graph.to_s.split("\n").
+            map {|t| t.gsub(/^\s*(.*)\s*$/, '\1')}.
+            reject {|t2| t2.match(/^\s*$/)}.
+            compact.
+            sort.
+            uniq
+        end
+        
+        # Implement to_ntriples on array, to simplify logic later
+        def array.to_ntriples; self.join("\n") + "\n"; end
+        array
       else
-        triples = [graph].flatten.join("\n")
-        N3Parser.parse(graph.to_s, @info.about, :strict => true)
+        case graph
+        when Graph then graph
+        when Parser then graph.graph
+        when IO, StringIO
+          Parser.parse(graph, @info.about)
+        else
+          parser = Parser.new(:struct => true)
+          fmt = parser.detect_format(graph.to_s)
+          parser.parse(graph.to_s, @info.about, :type => fmt)
+        end
       end
     end
     
     def initialize(expected, info)
-      @info = info
+      @info = if info.respond_to?(:about)
+        info
+      elsif info.is_a?(Hash)
+        identifier = info[:identifier] || expected.is_a?(Graph) ? expected.identifier : info[:about]
+        Info.new(identifier, info[:information] || "", info[:trace], info[:compare])
+      else
+        Info.new(expected.is_a?(Graph) ? expected.identifier : info, info.to_s)
+      end
       @expected = normalize(expected)
     end
 
@@ -24,69 +69,77 @@ module Matchers
 
     def failure_message_for_should
       info = @info.respond_to?(:information) ? @info.information : ""
-      if @actual.size != @expected.size
+      if @expected.is_a?(Graph) && @actual.size != @expected.size
         "Graph entry count differs:\nexpected: #{@expected.size}\nactual:   #{@actual.size}"
-      elsif @actual.identifier != @expected.identifier
+      elsif @expected.is_a?(Array) && @actual.size != @expected.length
+        "Graph entry count differs:\nexpected: #{@expected.length}\nactual:   #{@actual.size}"
+      elsif @expected.is_a?(Graph) && @actual.identifier != @expected.identifier
         "Graph identifiers differ:\nexpected: #{@expected.identifier}\nactual:   #{@actual.identifier}"
       else
-        "Graph differs\n"
+        "Graph differs#{@info.compare == :array ? '(array)' : ''}\n"
       end +
-      "\n\n#{info + "\n" unless info.empty?}" +
+      "\n#{info + "\n" unless info.empty?}" +
+      (@info.inputDocument ? "Input file: #{@info.inputDocument}\n" : "") +
+      (@info.outputDocument ? "Output file: #{@info.outputDocument}\n" : "") +
       "Unsorted Expected:\n#{@expected.to_ntriples}" +
       "Unsorted Results:\n#{@actual.to_ntriples}" +
-      (@info.respond_to?(:trace) ? "\nDebug:\n#{@info.trace}" : "")
+      (@info.trace ? "\nDebug:\n#{@info.trace}" : "")
     end
     def negative_failure_message
       "Graphs do not differ\n"
     end
   end
   
-  def be_equivalent_graph(expected, info = "")
+  def be_equivalent_graph(expected, info = nil)
     BeEquivalentGraph.new(expected, info)
   end
 
   # Run expected SPARQL query against actual
-  class PassQuery
-    def initialize(expected, info)
-      @expected = expected
-      @query = Redland::Query.new(expected)
-      @info = info
-    end
-    def matches?(actual)
-      @actual = actual
-      @expected_results = @info.respond_to?(:expectedResults) ? @info.expectedResults : true
-      model = Redland::Model.new
-      ntriples_parser = Redland::Parser.ntriples
-      ntriples_parser.parse_string_into_model(model, actual.to_ntriples, "http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/")
+  if $redland_enabled
+    class PassQuery
+      def initialize(expected, info)
+        @expected = expected
+        @query = Redland::Query.new(expected)
+        @info = info
+      end
+      def matches?(actual)
+        @actual = actual
+        @expected_results = @info.respond_to?(:expectedResults) ? @info.expectedResults : true
+        model = Redland::Model.new
+        ntriples_parser = Redland::Parser.ntriples
+        ntriples_parser.parse_string_into_model(model, actual.to_ntriples, "http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/")
 
-      @results = @query.execute(model)
-      if @expected_results
-        @results.is_boolean? && @results.get_boolean?
-      else
-        @results.nil? || @results.is_boolean? && !@results.get_boolean?
+        @results = @query.execute(model)
+        if @expected_results
+          @results.is_boolean? && @results.get_boolean?
+        else
+          @results.nil? || @results.is_boolean? && !@results.get_boolean?
+        end
+      end
+      def failure_message_for_should
+        info = @info.respond_to?(:information) ? @info.information : ""
+        "#{info + "\n" unless info.empty?}" +
+        if @results.nil?
+          "Query failed to return results"
+        elsif !@results.is_boolean?
+          "Query returned non-boolean results"
+        elsif @expected_results
+          "Query returned false"
+        else
+          "Query returned true (expected false)"
+        end +
+        "\n#{@expected}" +
+        "\n#{@info.input}" +
+        "\nResults:\n#{@actual.to_ntriples}" +
+        "\nDebug:\n#{@info.trace}"
       end
     end
-    def failure_message_for_should
-      info = @info.respond_to?(:information) ? @info.information : ""
-      "#{info + "\n" unless info.empty?}" +
-      if @results.nil?
-        "Query failed to return results"
-      elsif !@results.is_boolean?
-        "Query returned non-boolean results"
-      elsif @expected_results
-        "Query returned false"
-      else
-        "Query returned true (expected false)"
-      end +
-      "\n#{@expected}" +
-      "\n#{@info.input}" +
-      "\nResults:\n#{@actual.to_ntriples}" +
-      "\nDebug:\n#{@info.trace}"
-    end
-  end
 
-  def pass_query(expected, info = "")
-    PassQuery.new(expected, info)
+    def pass_query(expected, info = "")
+      PassQuery.new(expected, info)
+    end
+  else
+    def pass_query(expect, info = ""); false; end
   end
 
   class BeValidXML

data/spec/n3parser_spec.rb

@@ -1,12 +1,13 @@
+# coding: utf-8
 require File.join(File.dirname(__FILE__), 'spec_helper')
 include RdfContext
 
 describe "N3 parser" do
   before(:each) { @parser = N3Parser.new(:strict => true) }
   
-  describe "parse simple ntriples" do
+  describe "with simple ntriples" do
     it "should parse simple triple" do
-      n3_string = "<http://example.org/> <http://xmlns.com/foaf/0.1/name> \"Tom Morris\" . "
+      n3_string = %(<http://example.org/> <http://xmlns.com/foaf/0.1/name> "Tom Morris" .)
       @parser.parse(n3_string)
       @parser.graph[0].subject.to_s.should == "http://example.org/"
       @parser.graph[0].predicate.to_s.should == "http://xmlns.com/foaf/0.1/name"
@@ -24,7 +25,7 @@ describe "N3 parser" do
     end
 
     # NTriple tests from http://www.w3.org/2000/10/rdf-tests/rdfcore/ntriples/test.nt
-    describe "recognize blank lines" do
+    describe "with blank lines" do
       {
         "comment"                   => "# comment lines",
         "comment after whitespace"  => "            # comment after whitespace",
@@ -38,6 +39,66 @@ describe "N3 parser" do
       end
     end
 
+    describe "with literal encodings" do
+      {
+        'Dürst' => ':a :b "D\u00FCrst" .',
+        'simple literal' => ':a :b  "simple literal" .',
+        'backslash:\\' => ':a :b  "backslash:\\\\" .',
+        'dquote:"' => ':a :b  "dquote:\"" .',
+        "newline:\n" => ':a :b  "newline:\n" .',
+        "return\r" => ':a :b  "return\r" .',
+        "tab:\t" => ':a :b  "tab:\t" .',
+        "é" => ':a :b  "\u00E9" .',
+        "€" => ':a :b  "\u20AC" .',
+      }.each_pair do |contents, triple|
+        specify "test #{contents}" do
+          @parser.parse(triple, "http://a/b")
+          @parser.graph.should_not be_nil
+          @parser.graph.size.should == 1
+          @parser.graph[0].object.contents.should == contents
+        end
+      end
+      
+      it "should parse long literal with escape" do
+        n3 = %(@prefix : <http://example.org/foo#> . :a :b "\\U00015678another" .)
+        if defined?(::Encoding)
+          @parser.parse(n3)
+          @parser.graph[0].object.contents.should == "\u{15678}another"
+        else
+          lambda { @parser.parse(n3) }.should raise_error(RdfException, "Long Unicode escapes no supported in Ruby 1.8")
+          pending("Not supported in Ruby 1.8")
+        end
+      end
+
+      it "should parse multi-line literal" do
+        @parser.parse(%(
+  <http://www.example.com/books#book12345> <http://purl.org/dc/elements/1.1/title> """
+          Foo
+          <html:b xmlns:html="http://www.w3.org/1999/xhtml" html:a="b">bar<rdf:Thing xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"><a:b xmlns:a="foo:"></a:b>here<a:c xmlns:a="foo:"></a:c></rd
+  f:Thing></html:b>
+          baz
+          <html:i xmlns:html="http://www.w3.org/1999/xhtml">more</html:i>
+       """ .
+        ))
+
+        @parser.graph.should_not be_nil
+        @parser.graph.size.should == 1
+        @parser.graph[0].object.contents.should == %(
+          Foo
+          <html:b xmlns:html="http://www.w3.org/1999/xhtml" html:a="b">bar<rdf:Thing xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"><a:b xmlns:a="foo:"></a:b>here<a:c xmlns:a="foo:"></a:c></rd
+  f:Thing></html:b>
+          baz
+          <html:i xmlns:html="http://www.w3.org/1999/xhtml">more</html:i>
+       )
+      end
+      
+      it "should parse long literal ending in double quote" do
+        @parser.parse(%(:a :b """ \\"""" .), "http://a/b")
+        @parser.graph.size.should == 1
+        @parser.graph[0].object.contents.should == ' "'
+      end
+    end
+
     it "should create named subject bnode" do
       @parser.parse("_:anon <http://example.org/property> <http://example.org/resource2> .")
       @parser.graph.should_not be_nil
@@ -49,6 +110,17 @@ describe "N3 parser" do
       triple.object.should == "http://example.org/resource2"
     end
 
+    it "should create named predicate bnode" do
+      @parser.parse("<http://example.org/resource2> _:anon <http://example.org/object> .")
+      @parser.graph.should_not be_nil
+      @parser.graph.size.should == 1
+      triple = @parser.graph[0]
+      triple.subject.should == "http://example.org/resource2"
+      triple.predicate.should be_a(BNode)
+      triple.predicate.identifier.should =~ /anon/
+      triple.object.should == "http://example.org/object"
+    end
+
     it "should create named object bnode" do
       @parser.parse("<http://example.org/resource2> <http://example.org/property> _:anon .")
       @parser.graph.should_not be_nil
@@ -96,89 +168,736 @@ describe "N3 parser" do
         @parser.graph[0].to_ntriples.should == [statement].flatten.last.gsub(/\s+/, " ").strip
       end
     end
+
+    it "should create typed literals" do
+      n3doc = "<http://example.org/joe> <http://xmlns.com/foaf/0.1/name> \"Joe\"^^<http://www.w3.org/2001/XMLSchema#string> ."
+      @parser.parse(n3doc)
+      @parser.graph[0].object.class.should == RdfContext::Literal
+    end
+
+    it "should create BNodes" do
+      n3doc = "_:a a _:c ."
+      @parser.parse(n3doc)
+      @parser.graph[0].subject.class.should == RdfContext::BNode
+      @parser.graph[0].object.class.should == RdfContext::BNode
+    end
+
+    describe "should create URIRefs" do
+      {
+        %(<http://example.org/joe> <http://xmlns.com/foaf/0.1/knows> <http://example.org/jane> .) => %(<http://example.org/joe> <http://xmlns.com/foaf/0.1/knows> <http://example.org/jane> .),
+        %(<joe> <knows> <jane> .) => %(<http://a/joe> <http://a/knows> <http://a/jane> .),
+        %(:joe :knows :jane .) => %(<http://a/b#joe> <http://a/b#knows> <http://a/b#jane> .),
+        %(<#D%C3%BCrst>  a  "URI percent ^encoded as C3, BC".) => %(<http://a/b#D%C3%BCrst> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> "URI percent ^encoded as C3, BC" .),
+      }.each_pair do |n3, nt|
+        it "for '#{n3}'" do
+          @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+        end
+      end
+
+      {
+        %(<#Dürst>       a  "URI straight in UTF8".) => %(<http://a/b#D\\u00FCrst> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> "URI straight in UTF8" .),
+        %(:a :related :\u3072\u3089\u304C\u306A.) => %(<http://a/b#a> <http://a/b#related> <http://a/b#\\u3072\\u3089\\u304C\\u306A> .),
+      }.each_pair do |n3, nt|
+        it "for '#{n3}'" do
+          begin
+            @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+          rescue
+            if defined?(::Encoding)
+              raise
+            else
+              pending("Unicode URIs not supported in Ruby 1.8") {  raise } 
+            end
+          end
+        end
+      end
+    end
+    
+    it "should create URIRefs" do
+      n3doc = "<http://example.org/joe> <http://xmlns.com/foaf/0.1/knows> <http://example.org/jane> ."
+      @parser.parse(n3doc)
+      @parser.graph[0].subject.class.should == RdfContext::URIRef
+      @parser.graph[0].object.class.should == RdfContext::URIRef
+    end
+
+    it "should create literals" do
+      n3doc = "<http://example.org/joe> <http://xmlns.com/foaf/0.1/name> \"Joe\"."
+      @parser.parse(n3doc)
+      @parser.graph[0].object.class.should == RdfContext::Literal
+    end
   end
   
-  describe "literal encodings" do
+  describe "with illegal syntax" do
     {
-      'Dürst' => '_:a <http://example.org/named> "D\u00FCrst" .',
-      'simple literal' => '<http://example.org/resource7> <http://example.org/property> "simple literal" .',
-      'backslash:\\' => '<http://example.org/resource8> <http://example.org/property> "backslash:\\\\" .',
-      'dquote:"' => '<http://example.org/resource9> <http://example.org/property> "dquote:\"" .',
-      "newline:\n" => '<http://example.org/resource10> <http://example.org/property> "newline:\n" .',
-      "return\r" => '<http://example.org/resource11> <http://example.org/property> "return\r" .',
-      "tab:\t" => '<http://example.org/resource12> <http://example.org/property> "tab:\t" .',
-      "é" => '<http://example.org/resource16> <http://example.org/property> "\u00E9" .',
-      "€" => '<http://example.org/resource17> <http://example.org/property> "\u20AC" .',
-    }.each_pair do |contents, triple|
-      specify "test #{contents}" do
-        @parser.parse(triple)
-        @parser.graph.should_not be_nil
-        @parser.graph.size.should == 1
-        @parser.graph[0].object.contents.should == contents
+      %(:y :p1 "xyz"^^xsd:integer .) => %r(Typed literal has an invalid lexical value: .* "xyz"),
+      %(:y :p1 "12xyz"^^xsd:integer .) => %r(Typed literal has an invalid lexical value: .* "12xyz"),
+      %(:y :p1 "xy.z"^^xsd:double .) => %r(Typed literal has an invalid lexical value: .* "xy\.z"),
+      %(:y :p1 "+1.0z"^^xsd:double .) => %r(Typed literal has an invalid lexical value: .* "\+1.0z"),
+      %(:a :b .) => %r(Illegal statment: ".*" missing object),
+      %(:a :b 'single quote' .) => RdfException,
+      %(:a "literal value" :b .) => InvalidPredicate,
+      %(@keywords prefix. :e prefix :f .) => %r(Keyword ".*" used as expression)
+    }.each_pair do |n3, error|
+      it "should raise error for '#{n3}'" do
+        lambda {
+          @parser.parse("@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{n3}", "http://a/b")
+        }.should raise_error(error)
       end
     end
   end
   
-  # n3p tests taken from http://inamidst.com/n3p/test/
-  describe "parsing n3p test" do
-   dir_name = File.join(File.dirname(__FILE__), '..', 'test', 'n3_tests', 'n3p', '*.n3')
-    Dir.glob(dir_name).each do |n3|    
-      it n3 do
-        test_file(n3)
+  describe "with n3 grammer" do
+    describe "syntactic expressions" do
+      it "should create typed literals with qname" do
+        n3doc = %(
+          @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+          @prefix foaf: <http://xmlns.com/foaf/0.1/>
+          @prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+          <http://example.org/joe> foaf:name \"Joe\"^^xsd:string .
+        )
+        @parser.parse(n3doc)
+        @parser.graph[0].object.class.should == RdfContext::Literal
       end
+
+      it "should map <> to document uri" do
+        n3doc = "@prefix : <> ."
+        @parser.parse(n3doc, "http://the.document.itself")
+        @parser.graph.nsbinding.should == {"" => Namespace.new("http://the.document.itself", "", true)}
+      end
+
+      it "should use <> as a prefix and as a triple node" do
+        n3 = %(@prefix : <> . <> a :a.)
+        nt = %(
+        <http://a/b> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://a/b#a> .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should use <#> as a prefix and as a triple node" do
+        n3 = %(@prefix : <#> . <#> a :a.)
+        nt = %(
+        <http://a/b#> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://a/b#a> .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should generate rdf:type for 'a'" do
+        n3 = %(@prefix a: <http://foo/a#> . a:b a <http://www.w3.org/2000/01/rdf-schema#resource> .)
+        nt = %(<http://foo/a#b> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/01/rdf-schema#resource> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should generate rdf:type for '@a'" do
+        n3 = %(@prefix a: <http://foo/a#> . a:b @a <http://www.w3.org/2000/01/rdf-schema#resource> .)
+        nt = %(<http://foo/a#b> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/01/rdf-schema#resource> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should generate inverse predicate for 'is xxx of'" do
+        n3 = %("value" is :prop of :b . :b :prop "value"  .)
+        nt = %(<http://a/b#b> <http://a/b#prop> "value" .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should generate inverse predicate for '@is xxx @of'" do
+        n3 = %("value" @is :prop @of :b . :b :prop "value" .)
+        nt = %(<http://a/b#b> <http://a/b#prop> "value" .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should generate inverse predicate for 'is xxx of' with object list" do
+        n3 = %("value" is :prop of :b, :c . )
+        nt = %(
+        <http://a/b#b> <http://a/b#prop> "value" .
+        <http://a/b#c> <http://a/b#prop> "value" .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should generate predicate for 'has xxx'" do
+        n3 = %(@prefix a: <http://foo/a#> . a:b has :pred a:c .)
+        nt = %(<http://foo/a#b> <http://a/b#pred> <http://foo/a#c> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should generate predicate for '@has xxx'" do
+        n3 = %(@prefix a: <http://foo/a#> . a:b @has :pred a:c .)
+        nt = %(<http://foo/a#b> <http://a/b#pred> <http://foo/a#c> .)
+          @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should create log:implies predicate for '=>'" do
+        n3 = %(@prefix a: <http://foo/a#> . _:a => a:something .)
+        nt = %(_:a <http://www.w3.org/2000/10/swap/log#implies> <http://foo/a#something> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      it "should create log:implies inverse predicate for '<='" do
+        n3 = %(@prefix a: <http://foo/a#> . _:a <= a:something .)
+        nt = %(<http://foo/a#something> <http://www.w3.org/2000/10/swap/log#implies> _:a .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      it "should create owl:sameAs predicate for '='" do
+        n3 = %(@prefix a: <http://foo/a#> . _:a = a:something .)
+        nt = %(_:a <http://www.w3.org/2002/07/owl#sameAs> <http://foo/a#something> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      {
+        %(:a :b @true)  => %(<http://a/b#a> <http://a/b#b> "true"^^<http://www.w3.org/2001/XMLSchema#boolean> .),
+        %(:a :b @false)  => %(<http://a/b#a> <http://a/b#b> "false"^^<http://www.w3.org/2001/XMLSchema#boolean> .),
+        %(:a :b 1)  => %(<http://a/b#a> <http://a/b#b> "1"^^<http://www.w3.org/2001/XMLSchema#integer> .),
+        %(:a :b -1)  => %(<http://a/b#a> <http://a/b#b> "-1"^^<http://www.w3.org/2001/XMLSchema#integer> .),
+        %(:a :b +1)  => %(<http://a/b#a> <http://a/b#b> "+1"^^<http://www.w3.org/2001/XMLSchema#integer> .),
+        %(:a :b 1.0)  => %(<http://a/b#a> <http://a/b#b> "1.0"^^<http://www.w3.org/2001/XMLSchema#decimal> .),
+        %(:a :b 1.0e1)  => %(<http://a/b#a> <http://a/b#b> "1.0e1"^^<http://www.w3.org/2001/XMLSchema#double> .),
+        %(:a :b 1.0e-1)  => %(<http://a/b#a> <http://a/b#b> "1.0e-1"^^<http://www.w3.org/2001/XMLSchema#double> .),
+        %(:a :b 1.0e+1)  => %(<http://a/b#a> <http://a/b#b> "1.0e+1"^^<http://www.w3.org/2001/XMLSchema#double> .),
+      }.each_pair do |n3, nt|
+        it "should create typed literal for '#{n3}'" do
+          @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+        end
+      end
+      
+      it "should accept empty localname" do
+        n3 = %(: : : .)
+        nt = %(<http://a/b#> <http://a/b#> <http://a/b#> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should accept prefix with empty local name" do
+        n3 = %(@prefix foo: <http://foo/bar#> . foo: foo: foo: .)
+        nt = %(<http://foo/bar#> <http://foo/bar#> <http://foo/bar#> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should do something for @forAll"
+
+      it "should do something for @forSome"
     end
-  end
-  
-  describe "parsing real data tests" do
-    dirs = [ 'misc', 'lcsh' ]
-    dirs.each do |dir|
-      dir_name = File.join(File.dirname(__FILE__), '..', 'test', 'n3_tests', dir, '*.n3')
-      Dir.glob(dir_name).each do |n3|
-        it "#{dir} #{n3}" do
-          test_file(n3)
+    
+    describe "namespaces" do
+      it "should set absolute base" do
+        n3 = %(@base <http://foo/bar> . <> :a <b> . <#c> :d </e>.)
+        nt = %(
+        <http://foo/bar> <http://foo/bara> <http://foo/b> .
+        <http://foo/bar#c> <http://foo/bard> <http://foo/e> .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should set absolute base (trailing /)" do
+        n3 = %(@base <http://foo/bar/> . <> :a <b> . <#c> :d </e>.)
+        nt = %(
+        <http://foo/bar/> <http://foo/bar/a> <http://foo/bar/b> .
+        <http://foo/bar/#c> <http://foo/bar/d> <http://foo/e> .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should set absolute base (trailing #)" do
+        n3 = %(@base <http://foo/bar#> . <> :a <b> . <#c> :d </e>.)
+        nt = %(
+        <http://foo/bar> <http://foo/bar#a> <http://foo/b> .
+        <http://foo/bar#c> <http://foo/bar#d> <http://foo/e> .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should set relative base" do
+        n3 = %(
+        @base <http://example.org/products/>.
+        <> :a <b>, <#c>.
+        @base <prod123/>.
+        <> :a <b>, <#c>.
+        @base <../>.
+        <> :a <d>, <#e>.
+        )
+        nt = %(
+        <http://example.org/products/> <http://example.org/products/a> <http://example.org/products/b> .
+        <http://example.org/products/> <http://example.org/products/a> <http://example.org/products/#c> .
+        <http://example.org/products/prod123/> <http://example.org/products/prod123/a> <http://example.org/products/prod123/b> .
+        <http://example.org/products/prod123/> <http://example.org/products/prod123/a> <http://example.org/products/prod123/#c> .
+        <http://example.org/products/> <http://example.org/products/a> <http://example.org/products/d> .
+        <http://example.org/products/> <http://example.org/products/a> <http://example.org/products/#e> .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should bind named namespace" do
+        n3doc = "@prefix ns: <http://the/namespace#> ."
+        @parser.parse(n3doc, "http://a/b")
+        @parser.graph.nsbinding.should == {"ns" => Namespace.new("http://the/namespace#", "ns")}
+      end
+      
+      it "should bind empty prefix to <%> by default" do
+        n3doc = "@prefix : <#> ."
+        @parser.parse(n3doc, "http://the.document.itself")
+        @parser.graph.nsbinding.should == {"" => Namespace.new("http://the.document.itself#", "")}
+      end
+
+      it "should be able to bind _ as namespace" do
+        n3 = %(@prefix _: <http://underscore/> . _:a a _:p.)
+        nt = %(<http://underscore/a> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://underscore/p> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+    end
+    
+    describe "keywords" do
+      [
+        %(prefix :<>.),
+        %(base <>.),
+        %(keywords a.),
+        %(:a is :b of :c.),
+        %(:a @is :b of :c.),
+        %(:a is :b @of :c.),
+        %(:a has :b :c.),
+      ].each do |n3|
+        it "should require @ if keywords set to empty for '#{n3}'" do
+          lambda do
+            @parser.parse("@keywords . #{n3}", "http://a/b")
+          end.should raise_error(/unqualified keyword '\w+' used without @keyword directive/)
         end
       end
+      
+      {
+        %(:a a :b)  => %(<http://a/b#a> <http://a/b#a> <http://a/b#b> .),
+        %(:a :b true) => %(<http://a/b#a> <http://a/b#b> <http://a/b#true> .),
+        %(:a :b false) => %(<http://a/b#a> <http://a/b#b> <http://a/b#false> .),
+        %(c :a :t)  => %(<http://a/b#c> <http://a/b#a> <http://a/b#t> .),
+        %(:c a :t)  => %(<http://a/b#c> <http://a/b#a> <http://a/b#t> .),
+        %(:c :a t)  => %(<http://a/b#c> <http://a/b#a> <http://a/b#t> .),
+      }.each_pair do |n3, nt|
+        it "should use default_ns for '#{n3}'" do
+          @parser.parse("@keywords . #{n3}", "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+        end
+      end
+
+      {
+        %(@keywords true. :a :b true.) => %(<http://a/b#a> <http://a/b#b> "true"^^<http://www.w3.org/2001/XMLSchema#boolean> .),
+        %(@keywords false. :a :b false.) => %(<http://a/b#a> <http://a/b#b> "false"^^<http://www.w3.org/2001/XMLSchema#boolean> .),
+        %(@keywords a. :a a :b.) => %(<http://a/b#a> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://a/b#b> .),
+        %(@keywords is. :a is :b @of :c.) => %(<http://a/b#c> <http://a/b#b> <http://a/b#a> .),
+        %(@keywords of. :a @is :b of :c.) => %(<http://a/b#c> <http://a/b#b> <http://a/b#a> .),
+        %(@keywords has. :a has :b :c.) => %(<http://a/b#a> <http://a/b#b> <http://a/b#c> .),
+      }  .each_pair do |n3, nt|
+          it "should use keyword for '#{n3}'" do
+            @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+          end
+        end
+      
+      it "should raise error if unknown keyword set" do
+        n3 = %(@keywords foo.)
+        lambda do
+          @parser.parse(n3, "http://a/b")
+        end.should raise_error(ParserException, "undefined keywords used: foo")
+      end
     end
-  end
-  
-  it "should throw an exception when presented with a BNode as a predicate" do
-    n3doc = "_:a _:b _:c ."
-    lambda { @parser.parse(n3doc) }.should raise_error(RdfContext::Triple::InvalidPredicate)
-  end
+    
+    describe "declaration ordering" do
+      it "should process _ namespace binding after an initial use as a BNode" do
+        n3 = %(
+        _:a a :p.
+        @prefix _: <http://underscore/> .
+        _:a a :p.
+        )
+        nt = %(
+        <http://underscore/a> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> :p .
+        _:a <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> :p .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      it "should allow a prefix to be redefined" do
+        n3 = %(
+        @prefix a: <http://host/A#>.
+        a:b a:p a:v .
 
-  it "should create BNodes" do
-    n3doc = "_:a a _:c ."
-    @parser.parse(n3doc)
-    @parser.graph[0].subject.class.should == RdfContext::BNode
-    @parser.graph[0].object.class.should == RdfContext::BNode
-  end
-  
-  it "should create URIRefs" do
-    n3doc = "<http://example.org/joe> <http://xmlns.com/foaf/0.1/knows> <http://example.org/jane> ."
-    @parser.parse(n3doc)
-    @parser.graph[0].subject.class.should == RdfContext::URIRef
-    @parser.graph[0].object.class.should == RdfContext::URIRef
-  end
-  
-  it "should create literals" do
-    n3doc = "<http://example.org/joe> <http://xmlns.com/foaf/0.1/name> \"Joe\"."
-    @parser.parse(n3doc)
-    @parser.graph[0].object.class.should == RdfContext::Literal
-  end
-  
-  it "should create typed literals" do
-    n3doc = "<http://example.org/joe> <http://xmlns.com/foaf/0.1/name> \"Joe\"^^<http://www.w3.org/2001/XMLSchema#string> ."
-    @parser.parse(n3doc)
-    @parser.graph[0].object.class.should == RdfContext::Literal
-  end
-  
-  it "should map <#> to document uri" do
-    n3doc = "@prefix : <#> ."
-    @parser.parse(n3doc, "http://the.document.itself")
-    @parser.graph.nsbinding.should == {"__local__", Namespace.new("http://the.document.itself", "__local__")}
+        @prefix a: <http://host/Z#>.
+        a:b a:p a:v .
+        )
+        nt = %(
+        <http://host/A#b> <http://host/A#p> <http://host/A#v> .
+        <http://host/Z#b> <http://host/Z#p> <http://host/Z#v> .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+
+      it "should process sequential @base declarations (swap base.n3)" do
+        n3 = %(
+        @base <http://example.com/ontolgies>. <a> :b <foo/bar#baz>.
+        @base <path/DFFERENT/>. <a2> :b2 <foo/bar#baz2>.
+        @prefix : <#>. <d3> :b3 <e3>.
+        )
+        nt = %(
+        <http://example.com/a> <http://example.com/ontolgiesb> <http://example.com/foo/bar#baz> .
+        <http://example.com/path/DFFERENT/a2> <http://example.com/path/DFFERENT/b2> <http://example.com/path/DFFERENT/foo/bar#baz2> .
+        <http://example.com/path/DFFERENT/d3> <http://example.com/path/DFFERENT/#b3> <http://example.com/path/DFFERENT/e3> .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+    end
+    
+    describe "BNodes" do
+      it "should create BNode for identifier with '_' prefix" do
+        n3 = %(@prefix a: <http://foo/a#> . _:a a:p a:v .)
+        nt = %(_:bnode0 <http://foo/a#p> <http://foo/a#v> .)
+      end
+      
+      it "should create BNode for [] as subject" do
+        n3 = %(@prefix a: <http://foo/a#> . [] a:p a:v .)
+        nt = %(_:bnode0 <http://foo/a#p> <http://foo/a#v> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      it "should create BNode for [] as predicate" do
+        n3 = %(@prefix a: <http://foo/a#> . a:s [] a:o .)
+        nt = %(<http://foo/a#s> _:bnode0 <http://foo/a#o> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      it "should create BNode for [] as object" do
+        n3 = %(@prefix a: <http://foo/a#> . a:s a:p [] .)
+        nt = %(<http://foo/a#s> <http://foo/a#p> _:bnode0 .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      it "should create BNode for [] as statement" do
+        n3 = %([:a :b] .)
+        nt = %(_:bnode0 <http://a/b#a> <http://a/b#b> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      it "should create statements with BNode subjects using [ pref obj]" do
+        n3 = %(@prefix a: <http://foo/a#> . [ a:p a:v ] .)
+        nt = %(_:bnode0 <http://foo/a#p> <http://foo/a#v> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      it "should create BNode as a single object" do
+        n3 = %(@prefix a: <http://foo/a#> . a:b a:oneRef [ a:pp "1" ; a:qq "2" ] .)
+        nt = %(
+        _:bnode0 <http://foo/a#pp> "1" .
+        _:bnode0 <http://foo/a#qq> "2" .
+        <http://foo/a#b> <http://foo/a#oneRef> _:bnode0 .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      it "should create a shared BNode" do
+        n3 = %(
+        @prefix a: <http://foo/a#> .
+
+        a:b1 a:twoRef _:a .
+        a:b2 a:twoRef _:a .
+
+        _:a :pred [ a:pp "1" ; a:qq "2" ].
+        )
+        nt = %(
+        <http://foo/a#b1> <http://foo/a#twoRef> _:a .
+        <http://foo/a#b2> <http://foo/a#twoRef> _:a .
+        _:bnode0 <http://foo/a#pp> "1" .
+        _:bnode0 <http://foo/a#qq> "2" .
+        _:a :pred _:bnode0 .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      it "should create nested BNodes" do
+        n3 = %(
+        @prefix a: <http://foo/a#> .
+
+        a:a a:p [ a:p2 [ a:p3 "v1" , "v2" ; a:p4 "v3" ] ; a:p5 "v4" ] .
+        )
+        nt = %(
+        _:bnode0 <http://foo/a#p3> "v1" .
+        _:bnode0 <http://foo/a#p3> "v2" .
+        _:bnode0 <http://foo/a#p4> "v3" .
+        _:bnode1 <http://foo/a#p2> _:bnode0 .
+        _:bnode1 <http://foo/a#p5> "v4" .
+        <http://foo/a#a> <http://foo/a#p> _:bnode1 .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+
+      describe "from paths" do
+        it "should create bnode for path x.p" do
+          n3 = %(:x2.:y2 :p2 "3" .)
+          nt = %(:x2 :y2 _:bnode0 . _:bnode0 :p2 "3" .)
+          @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+        end
+      
+        it "should create bnode for path x!p" do
+          n3 = %(:x2!:y2 :p2 "3" .)
+          nt = %(:x2 :y2 _:bnode0 . _:bnode0 :p2 "3" .)
+          @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+        end
+      
+        it "should create bnode for path x^p" do
+          n3 = %(:x2^:y2 :p2 "3" .)
+          nt = %(_:bnode0 :y2 :x2 . _:bnode0 :p2 "3" .)
+          @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+        end
+      
+        it "should decode :joe!fam:mother!loc:office!loc:zip as Joe's mother's office's zipcode" do
+          n3 = %(
+          @prefix fam: <http://foo/fam#> .
+          @prefix loc: <http://foo/loc#> .
+
+          :joe!fam:mother!loc:office!loc:zip .
+          )
+          nt = %(
+          :joe <http://foo/fam#mother> _:bnode0 .
+          _:bnode0 <http://foo/loc#office> _:bnode1 .
+          _:bnode1 <http://foo/loc#zip> _:bnode2 .
+          )
+          @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+        end
+
+        it "should decode :joe!fam:mother^fam:mother Anyone whose mother is Joe's mother." do
+          n3 = %(
+          @prefix fam: <http://foo/fam#> .
+          @prefix loc: <http://foo/loc#> .
+
+          :joe!fam:mother^fam:mother .
+          )
+          nt = %(
+          :joe <http://foo/fam#mother> _:bnode0 .
+          _:bnode1 <http://foo/fam#mother> _:bnode0 .
+          )
+          @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+        end
+
+        it "should decode path with property list." do
+          n3 = %(
+          @prefix a: <http://a/ns#>.
+          :a2.a:b2.a:c2 :q1 "3" ; :q2 "4" , "5" .
+          )
+          nt = %(
+          :a2 <http://a/ns#b2> _:bnode0 .
+          _:bnode0 <http://a/ns#c2> _:bnode1 .
+          _:bnode1 :q1 "3" .
+          _:bnode1 :q2 "4" .
+          _:bnode1 :q2 "5" .
+          )
+          @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+        end
+
+        it "should decode path as object(1)" do
+          n3 = %(:a  :b "lit"^:c.)
+          nt = %(
+            :a :b _:bnode .
+            _:bnode :c "lit" .
+          )
+          @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+        end
+
+        it "should decode path as object(2)" do
+          n3 = %(@prefix a: <http://a/ns#>. :r :p :o.a:p1.a:p2 .)
+          nt = %(
+          :o <http://a/ns#p1> _:bnode0 .
+          _:bnode0 <http://a/ns#p2> _:bnode1 .
+          :r :p _:bnode1 .
+          )
+          @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+        end
+      end
+    end
+    
+    describe "formulae" do
+      it "should require that graph be formula_aware when encountering a formlua"
+      
+      it "should separate triples between specified and quoted graphs"
+    end
+    
+    describe "object lists" do
+      it "should create 2 statements for simple list" do
+        n3 = %(:a :b :c, :d)
+        nt = %(<http://a/b#a> <http://a/b#b> <http://a/b#c> . <http://a/b#a> <http://a/b#b> <http://a/b#d> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+    end
+    
+    describe "property lists" do
+      it "should parse property list" do
+        n3 = %(
+        @prefix a: <http://foo/a#> .
+
+        a:b a:p1 "123" ; a:p1 "456" .
+        a:b a:p2 a:v1 ; a:p3 a:v2 .
+        )
+        nt = %(
+        <http://foo/a#b> <http://foo/a#p1> "123" .
+        <http://foo/a#b> <http://foo/a#p1> "456" .
+        <http://foo/a#b> <http://foo/a#p2> <http://foo/a#v1> .
+        <http://foo/a#b> <http://foo/a#p3> <http://foo/a#v2> .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+    end
+    
+    describe "lists" do
+      it "should parse empty list" do
+        n3 = %(@prefix :<http://example.com/>. :empty :set ().)
+        nt = %(
+        <http://example.com/empty> <http://example.com/set> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      
+      it "should parse list with single element" do
+        n3 = %(@prefix :<http://example.com/>. :gregg :wrote ("RdfContext").)
+        nt = %(
+        _:bnode0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "RdfContext" .
+        _:bnode0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+        <http://example.com/gregg> <http://example.com/wrote> _:bnode0 .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      it "should parse list with multiple elements" do
+        n3 = %(@prefix :<http://example.com/>. :gregg :name ("Gregg" "Barnum" "Kellogg").)
+        nt = %(
+        _:bnode0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "Gregg" .
+        _:bnode0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode1 .
+        _:bnode1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "Barnum" .
+        _:bnode1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode2 .
+        _:bnode2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "Kellogg" .
+        _:bnode2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+        <http://example.com/gregg> <http://example.com/name> _:bnode0 .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      it "should parse unattached lists" do
+        n3 = %(
+        @prefix a: <http://foo/a#> .
+
+        ("1" "2" "3") .
+        # This is not a statement.
+        () .
+        )
+        nt = %(
+        _:bnode0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "1" .
+        _:bnode0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode1 .
+        _:bnode1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "2" .
+        _:bnode1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode2 .
+        _:bnode2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "3" .
+        _:bnode2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+      it "should add property to nil list" do
+        n3 = %(@prefix a: <http://foo/a#> . () a:prop "nilProp" .)
+        nt = %(<http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> <http://foo/a#prop> "nilProp" .)
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug, :compare => :array)
+      end
+      it "should parse with compound items" do
+        n3 = %(
+        @prefix a: <http://foo/a#> .
+
+        a:a a:p ( [ a:p2 "v1" ] 
+        	  <http://resource1>
+        	  <http://resource2>
+        	  ("inner list") ) .
+
+        <http://resource1> a:p "value" .
+        )
+        nt = %(
+        _:bnode0 <http://foo/a#p2> "v1" .
+        _:bnode1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> _:bnode0 .
+        _:bnode1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode2 .
+        _:bnode2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://resource1> .
+        _:bnode2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode3 .
+        _:bnode3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://resource2> .
+        _:bnode4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "inner list" .
+        _:bnode4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+        _:bnode3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:bnode5 .
+        _:bnode5 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> _:bnode4 .
+        _:bnode5 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+        <http://foo/a#a> <http://foo/a#p> _:bnode1 .
+        <http://resource1> <http://foo/a#p> "value" .
+        )
+        @parser.parse(n3, "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @parser.debug)
+      end
+      
+    end
+    
+     # n3p tests taken from http://inamidst.com/n3p/test/
+    describe "with real data tests" do
+      dirs = %w(misc lcsh rdflib n3p)
+      dirs.each do |dir|
+        dir_name = File.join(File.dirname(__FILE__), '..', 'test', 'n3_tests', dir, '*.n3')
+        Dir.glob(dir_name).each do |n3|
+          it "#{dir} #{n3}" do
+            test_file(n3)
+          end
+        end
+      end
+    end
+
+    describe "with AggregateGraph tests" do
+      subject { Graph.new }
+
+      describe "with a type" do
+        before(:each) do
+          subject.parse(%(
+          @prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+          @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+          @prefix : <http://test/> .
+          :foo a rdfs:Class.
+          :bar :d :c.
+          :a :d :c.
+          ), "http://a/b")
+        end
+        
+        it "should have 3 namespaces" do
+          subject.nsbinding.keys.length.should == 3
+        end
+      end
+    
+      describe "with blank clause" do
+        before(:each) do
+          subject.parse(%(
+          @prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+          @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+          @prefix : <http://test/> .
+          @prefix log: <http://www.w3.org/2000/10/swap/log#>.
+          :foo a rdfs:Resource.
+          :bar rdfs:isDefinedBy [ a log:Formula ].
+          :a :d :e.
+          ), "http://a/b")
+        end
+        
+        it "should have 4 namespaces" do
+          subject.nsbinding.keys.length.should == 4
+        end
+      end
+    
+      describe "with empty subject" do
+        before(:each) do
+          subject.parse(%(
+          @prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+          @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+          @prefix log: <http://www.w3.org/2000/10/swap/log#>.
+          @prefix : <http://test/> .
+          <> a log:N3Document.
+          ), "http://test/")
+        end
+        
+        it "should have 4 namespaces" do
+          subject.nsbinding.keys.length.should == 4
+        end
+        
+        it "should have default subject" do
+          subject.size.should == 1
+          subject.triples.first.subject.should == "http://test/"
+        end
+      end
+    end
   end
 
-  it "should parse testcase" do
+  it "should parse rdf_core testcase" do
     sampledoc = <<-EOF;
 <http://www.w3.org/2000/10/rdf-tests/rdfcore/xmlbase/Manifest.rdf#test001> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#PositiveParserTest> .
 <http://www.w3.org/2000/10/rdf-tests/rdfcore/xmlbase/Manifest.rdf#test001> <http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#approval> <http://lists.w3.org/Archives/Public/w3c-rdfcore-wg/2002Mar/0235.html> .
@@ -190,40 +909,20 @@ describe "N3 parser" do
 <http://www.w3.org/2000/10/rdf-tests/rdfcore/xmlbase/test001.rdf> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#RDF-XML-Document> .
 EOF
     @parser.parse(sampledoc, "http://www.w3.org/2000/10/rdf-tests/rdfcore/amp-in-url/Manifest.rdf")
-    ntriples = @parser.graph.to_ntriples
-    ntriples = sort_ntriples(ntriples)
 
-    nt_string = sort_ntriples(sampledoc)
-    ntriples.should == nt_string    
+    @parser.graph.should be_equivalent_graph(sampledoc,
+      :about => "http://www.w3.org/2000/10/rdf-tests/rdfcore/amp-in-url/Manifest.rdf",
+      :trace => @parser.debug, :compare => :array
+    )
   end
-  
+
   def test_file(filepath)
-    anon = "a"
-    anon_ctx = {}
     n3_string = File.read(filepath)
     @parser.parse(n3_string, "file:#{filepath}")
-    ntriples = @parser.graph.to_ntriples
-    ntriples.gsub!(/_:nbn\d+[a-z]+N/, "_:")  # Normalize named BNodes
-    ntriples.gsub!(/_:bn\d+[a-z]+/) do |bn|
-      # Normalize anon BNodes
-      if anon_ctx[bn]
-        anon_ctx[bn]
-      else
-        anon_ctx[bn] = anon
-        anon = anon.succ
-      end
-      "_:#{anon_ctx[bn]}"
-    end
-    ntriples = sort_ntriples(ntriples)
 
     nt_string = File.read(filepath.sub('.n3', '.nt'))
-    nt_string = sort_ntriples(nt_string)
-
-    ntriples.should == nt_string    
+    @parser.graph.should be_equivalent_graph(nt_string,
+      :about => "file:#{filepath}",
+      :trace => @parser.debug)
   end
-  
-  def sort_ntriples(string)
-    string.split("\n").sort.join("\n")
-  end
-
 end