rdf-n3 0.3.4.1 → 0.3.5

data/spec/spec.opts

@@ -1 +0,0 @@
---colour

data/spec/spec_helper.rb

@@ -1,86 +0,0 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$:.unshift File.dirname(__FILE__)
-
-require 'rubygems'
-require 'rspec'
-require 'matchers'
-require 'bigdecimal'  # XXX Remove Me
-require 'rdf/n3'
-require 'rdf/ntriples'
-require 'rdf/spec'
-require 'rdf/spec/matchers'
-require 'rdf/isomorphic'
-require 'yaml'    # XXX should be in open-uri/cached
-require 'open-uri/cached'
-
-include Matchers
-
-# Create and maintain a cache of downloaded URIs
-URI_CACHE = File.expand_path(File.join(File.dirname(__FILE__), "uri-cache"))
-Dir.mkdir(URI_CACHE) unless File.directory?(URI_CACHE)
-OpenURI::Cache.class_eval { @cache_path = URI_CACHE }
-
-module RDF
-  module Isomorphic
-    alias_method :==, :isomorphic_with?
-  end
-  class Graph
-    def to_ntriples
-      RDF::Writer.for(:ntriples).buffer do |writer|
-        self.each_statement do |statement|
-          writer << statement
-        end
-      end
-    end
-    def dump
-      b = []
-      self.each_statement do |statement|
-        b << statement.to_triple.inspect
-      end
-      b.join("\n")
-    end
-  end
-end
-
-::RSpec.configure do |c|
-  c.filter_run :focus => true
-  c.run_all_when_everything_filtered = true
-  c.exclusion_filter = {
-    :ruby => lambda { |version| !(RUBY_VERSION.to_s =~ /^#{version.to_s}/) },
-  }
-  c.include(Matchers)
-  c.include(RDF::Spec::Matchers)
-end
-
-# Serialize graph and replace bnodes with predictable versions, return as sorted array  
-def normalize_bnodes(graph, anon = "a")
-  anon_ctx = {}
-  # Find and replace all BNodes within graph string
-  g_str = graph.to_ntriples
-  anon_entries = g_str.scan(/_:g\d+/).sort.uniq
-  anon_entries.each do |a|
-    anon_ctx[a] = "_:#{anon}"
-    anon = anon.succ
-  end
-  
-  g_str.gsub(/_:g\d+/) { |bn| anon_ctx[bn] }.split("\n").sort
-end
-
-# Heuristically detect the input stream
-def detect_format(stream)
-  # Got to look into the file to see
-  if stream.is_a?(IO) || stream.is_a?(StringIO)
-    stream.rewind
-    string = stream.read(1000)
-    stream.rewind
-  else
-    string = stream.to_s
-  end
-  case string
-  when /<\w+:RDF/ then :rdfxml
-  when /<RDF/     then :rdfxml
-  when /<html/i   then :rdfa
-  when /@prefix/i then :n3
-  else                 :n3
-  end
-end

data/spec/swap_spec.rb

@@ -1,78 +0,0 @@
-$:.unshift "."
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe RDF::N3::Reader do
-  # W3C N3 Test suite from http://www.w3.org/2000/10/swap/test/n3parser.tests
-  describe "w3c swap tests" do
-    require 'swap_test'
-
-    # Negative parser tests should raise errors.
-    describe "positive parser tests" do
-      Fixtures::SWAPTest::PositiveParserTest.each do |t|
-        #next unless t.subject.to_s =~ /rdfms-rdf-names-use/
-        #next unless t.name =~ /11/
-        #puts t.inspect
-        specify "#{t.name}: #{t.inputDocument} against #{t.outputDocument}" do
-          begin
-            t.run_test do
-              t.name.should_not == "n3_10012"  # Too many bnodes makes graph compare unfeasable
-              t.debug = []
-              g = RDF::Graph.new
-              RDF::N3::Reader.new(t.input,
-                  :base_uri => t.inputDocument,
-                  :strict => true,
-                  :debug => t.debug).each do |statement|
-                g << statement
-              end
-              g
-            end
-          rescue RSpec::Expectations::ExpectationNotMetError => e
-            if %w(n3_10012).include?(t.name)
-              pending("check visually, graph compare times too long")
-            elsif %w(n3_10010).include?(t.name)
-              pending("Not supported in Ruby 1.8")
-            elsif %w(n3_10008 n3_10013).include?(t.name)
-              pending("Isomorphic compare issue")
-            elsif %w(n3_10004 n3_10007 n3_10014 n3_10015 n3_10017).include?(t.name)
-              pending("Formulae inferrence not supported")
-            elsif %w(n3_10006 n3_10009).include?(t.name)
-              pending("Verified test results are incorrect")
-            else
-              raise
-            end
-          end
-        end
-      end
-    end
-
-    describe "negative parser tests" do
-      Fixtures::SWAPTest::NegativeParserTest.each do |t|
-        #next unless t.subject.uri.to_s =~ /rdfms-empty-property-elements/
-        #next unless t.name =~ /1/
-        #puts t.inspect
-        specify "#{t.name}: #{t.inputDocument}#{t.outputDocument ? (' against ' + t.outputDocument) : ''}" do
-          begin
-            t.run_test do
-              lambda do
-                t.debug = []
-                g = RDF::Graph.new
-                RDF::N3::Reader.new(t.input,
-                    :base_uri => t.inputDocument,
-                    :strict => true,
-                    :debug => t.debug).each do |statement|
-                  g << statement
-                end
-              end.should raise_error(RDF::ReaderError)
-            end
-          rescue RSpec::Expectations::ExpectationNotMetError => e
-            if %w(n3_10019 n3_10020).include?(t.name)
-              pending("This is still supported")
-            else
-              raise
-            end
-          end 
-        end
-      end
-    end
-  end
-end

data/spec/swap_test.rb

@@ -1,79 +0,0 @@
-# Spira class for manipulating test-manifest style test suites.
-# Used for SWAP tests
-require 'spira'
-require 'rdf/n3'
-require 'open-uri'
-
-module Fixtures
-  module SWAPTest
-    class N3T < RDF::Vocabulary("http://www.w3.org/2004/11/n3test#"); end
-
-    class Entry
-      attr_accessor :debug
-      attr_accessor :compare
-      include Spira::Resource
-
-      property :description, :predicate => N3T.description, :type => XSD.string
-      property :inputDocument, :predicate => N3T.inputDocument
-      property :outputDocument, :predicate => N3T.outputDocument
-
-      def name
-        subject.to_s.split("#").last
-      end
-
-      def input
-        Kernel.open(self.inputDocument)
-      end
-      
-      def output
-        self.outputDocument ? Kernel.open(self.outputDocument) : ""
-      end
-
-      def information; self.description; end
-      
-      def inspect
-        "[#{self.class.to_s} " + %w(
-          subject
-          description
-          inputDocument
-          outputDocument
-        ).map {|a| v = self.send(a); "#{a}='#{v}'" if v}.compact.join(", ") +
-        "]"
-      end
-
-      # Run test case, yields input for parser to create triples
-      def run_test(options = {})
-        # Run
-        graph = yield
-        
-        return unless self.outputDocument
-
-        case self.compare
-        when :none
-          # Don't check output, just parse to graph
-        when :array
-          @parser.graph.should be_equivalent_graph(self.output, self)
-        else
-          #puts "parse #{self.outputDocument} as #{RDF::Reader.for(self.outputDocument)}"
-          format = detect_format(self.output)
-          output_graph = RDF::Graph.load(self.outputDocument, :format => format, :base_uri => self.inputDocument)
-          puts "result: #{CGI.escapeHTML(graph.to_ntriples)}" if ::RDF::N3::debug?
-          graph.should Matchers::be_equivalent_graph(output_graph, self)
-        end
-      end
-    end
-    
-    class PositiveParserTest < Entry
-      default_source :entries
-      type N3T.PositiveParserTest
-    end
-
-    class NegativeParserTest < Entry
-      default_source :entries
-      type N3T.NegativeParserTest
-    end
-    
-    repo = RDF::Repository.load("http://www.w3.org/2000/10/swap/test/n3parser.tests", :format => :n3)
-    Spira.add_repository! :entries, repo
-  end
-end

data/spec/turtle_spec.rb

@@ -1,66 +0,0 @@
-$:.unshift "."
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe RDF::N3::Reader do
-  # W3C Turtle Test suite from http://www.w3.org/2000/10/swap/test/regression.n3
-  describe "w3c turtle tests" do
-    require 'turtle_test'
-
-    describe "positive parser tests" do
-      Fixtures::TurtleTest::Good.each do |t|
-        next unless t.comment
-        #puts t.inspect
-        
-        # modified test-10 results to be canonical
-        # modified test-21&22 results exponent to be E not e
-        # modified test-28 2.30 => 2.3 representation
-        specify "#{t.name}: #{t.comment}" do
-          #puts t.inspect
-          # Skip tests for very long files, too long
-          if !defined?(::Encoding) && %w(test-18).include?(t.name)
-            pending("Not supported in Ruby 1.8")
-          else
-            t.run_test do
-              t.debug = []
-              g = RDF::Graph.new
-              RDF::N3::Reader.new(t.input,
-                  :base_uri => t.inputDocument,
-                  :strict => true,
-                  :canonicalize => true,
-                  :debug => t.debug).each do |statement|
-                g << statement
-              end
-              g
-            end
-          end
-        end
-      end
-    end
-
-    describe "negative parser tests" do
-      Fixtures::TurtleTest::Bad.each do |t|
-        next unless t.comment
-        #puts t.inspect
-        specify "#{t.name}: #{t.comment}" do
-          begin
-            t.run_test do
-              lambda do
-                t.debug = []
-                 g = RDF::Graph.new
-                 RDF::N3::Reader.new(t.input,
-                     :base_uri => t.inputDocument,
-                     :strict => true,
-                     :debug => t.debug).each do |statement|
-                   g << statement
-                 end
-              end.should raise_error(RDF::ReaderError)
-            end
-          rescue RSpec::Expectations::ExpectationNotMetError => e
-            pending() {  raise }
-          end
-        end
-      end
-    end
-  end
-
-end

data/spec/turtle_test.rb

@@ -1,98 +0,0 @@
-# Spira class for manipulating test-manifest style test suites.
-# Used for Turtle tests
-require 'spira'
-require 'rdf/n3'
-require 'open-uri'
-
-module Fixtures
-  module TurtleTest
-    class MF < RDF::Vocabulary("http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#"); end
-
-    class Entry
-      attr_accessor :debug
-      attr_accessor :compare
-      include Spira::Resource
-      type MF["Entry"]
-
-      property :name, :predicate => MF["name"], :type => XSD.string
-      property :comment, :predicate => RDF::RDFS.comment, :type => XSD.string
-      property :result, :predicate => MF.result
-      has_many :action, :predicate => MF["action"]
-
-      def name
-        inputDocument.to_s.split("/").last
-      end
-
-      def input
-        Kernel.open(self.inputDocument)
-      end
-      
-      def output
-        self.result ? Kernel.open(self.result) : ""
-      end
-
-      def inputDocument
-        self.class.repository.first_object(:subject => self.action.first)
-      end
-      
-      def inspect
-        "[#{self.class.to_s} " + %w(
-          subject
-          name
-          comment
-          result
-          inputDocument
-        ).map {|a| v = self.send(a); "#{a}='#{v}'" if v}.compact.join(", ") +
-        "]"
-      end
-
-      # Run test case, yields input for parser to create triples
-      def run_test(options = {})
-        # Run
-        graph = yield
-        
-        return unless self.result
-
-        case self.compare
-        when :none
-          # Don't check output, just parse to graph
-        when :array
-          @parser.graph.should be_equivalent_graph(self.output, self)
-        else
-          #puts "parse #{self.outputDocument} as #{RDF::Reader.for(self.outputDocument)}"
-          format = detect_format(self.output)
-          output_graph = RDF::Graph.load(self.result, :format => format, :base_uri => self.inputDocument)
-          puts "result: #{CGI.escapeHTML(graph.to_ntriples)}" if ::RDF::N3::debug?
-          graph.should Matchers::be_equivalent_graph(output_graph, self)
-        end
-      end
-    end
-
-    class Good < Entry
-      default_source :turtle
-    end
-    
-    class Bad < Entry
-      default_source :turtle_bad
-    end
-    
-    turtle = RDF::Repository.load("http://www.w3.org/2001/sw/DataAccess/df1/tests/manifest.ttl")
-
-    # Add types to entries
-    turtle.subjects(:predicate => MF["name"]).each do |s|
-      turtle << RDF::Statement.new(s, RDF.type, MF["Entry"])
-    end
-
-    Spira.add_repository! :turtle, turtle
-    
-    turtle_bad = RDF::Repository.load("http://www.w3.org/2001/sw/DataAccess/df1/tests/manifest-bad.ttl")
-
-    # Add types to entries
-    turtle_bad.subjects(:predicate => MF["name"]).each do |s|
-      turtle_bad << RDF::Statement.new(s, RDF.type, MF["Entry"])
-    end
-
-    Spira.add_repository! :turtle_bad, turtle_bad
-    
-  end
-end

data/spec/writer_spec.rb

@@ -1,399 +0,0 @@
-$:.unshift "."
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe RDF::N3::Writer do
-  describe "simple tests" do
-    it "should use full URIs without base" do
-      input = %(<http://a/b> <http://a/c> <http://a/d> .)
-      serialize(input, nil, [%r(^<http://a/b> <http://a/c> <http://a/d> \.$)])
-    end
-
-    it "should use relative URIs with base" do
-      input = %(<http://a/b> <http://a/c> <http://a/d> .)
-      serialize(input, "http://a/",
-       [ %r(^@base <http://a/> \.$),
-        %r(^<b> <c> <d> \.$)]
-      )
-    end
-
-    it "should use qname URIs with prefix" do
-      input = %(<http://xmlns.com/foaf/0.1/b> <http://xmlns.com/foaf/0.1/c> <http://xmlns.com/foaf/0.1/d> .)
-      serialize(input, nil,
-        [%r(^@prefix foaf: <http://xmlns.com/foaf/0.1/> \.$),
-        %r(^foaf:b foaf:c foaf:d \.$)],
-        :prefixes => { :foaf => RDF::FOAF}
-      )
-    end
-
-    it "should use qname URIs with empty prefix" do
-      input = %(<http://xmlns.com/foaf/0.1/b> <http://xmlns.com/foaf/0.1/c> <http://xmlns.com/foaf/0.1/d> .)
-      serialize(input, nil,
-        [%r(^@prefix : <http://xmlns.com/foaf/0.1/> \.$),
-        %r(^:b :c :d \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-    
-    # see example-files/arnau-registered-vocab.rb
-    it "should use qname URIs with empty suffix" do
-      input = %(<http://xmlns.com/foaf/0.1/> <http://xmlns.com/foaf/0.1/> <http://xmlns.com/foaf/0.1/> .)
-      serialize(input, nil,
-        [%r(^@prefix foaf: <http://xmlns.com/foaf/0.1/> \.$),
-        %r(^foaf: foaf: foaf: \.$)],
-        :prefixes => { "foaf" => RDF::FOAF}
-      )
-    end
-    
-    it "should not use qname with illegal local part" do
-      input = %(
-        @prefix db: <http://dbpedia.org/resource/> .
-        @prefix dbo: <http://dbpedia.org/ontology/> .
-        db:Michael_Jackson dbo:artistOf <http://dbpedia.org/resource/%28I_Can%27t_Make_It%29_Another_Day> .
-      )
-
-      serialize(input, nil,
-        [%r(^@prefix db: <http://dbpedia.org/resource/> \.$),
-        %r(^db:Michael_Jackson dbo:artistOf <http://dbpedia.org/resource/%28I_Can%27t_Make_It%29_Another_Day> \.$)],
-        :prefixes => {
-          "db" => RDF::URI("http://dbpedia.org/resource/"),
-          "dbo" => RDF::URI("http://dbpedia.org/ontology/")}
-      )
-    end
-
-    it "should order properties" do
-      input = %(
-        @prefix : <http://xmlns.com/foaf/0.1/> .
-        @prefix dc: <http://purl.org/dc/elements/1.1/> .
-        @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
-        :b :c :d .
-        :b dc:title "title" .
-        :b a :class .
-        :b rdfs:label "label" .
-      )
-      serialize(input, nil,
-        [%r(^\s+a :class;$),
-        %r(^\s+rdfs:label "label"),
-        %r(^:b dc:title \"title\"),
-        %r(^\s+:c :d)],
-        :prefixes => { "" => RDF::FOAF, :dc => "http://purl.org/dc/elements/1.1/", :rdfs => RDF::RDFS}
-      )
-    end
-    
-    it "should generate object list" do
-      input = %(@prefix : <http://xmlns.com/foaf/0.1/> . :b :c :d, :e .)
-      serialize(input, nil,
-        [%r(^@prefix : <http://xmlns.com/foaf/0.1/> \.$),
-        %r(^:b :c :d,$),
-        %r(^\s+:e \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-    
-    it "should generate property list" do
-      input = %(@prefix : <http://xmlns.com/foaf/0.1/> . :b :c :d; :e :f .)
-      serialize(input, nil,
-        [%r(^@prefix : <http://xmlns.com/foaf/0.1/> \.$),
-        %r(^:b :c :d;$),
-        %r(^\s+:e :f \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-  end
-  
-  describe "anons" do
-    it "should generate bare anon" do
-      input = %(@prefix : <http://xmlns.com/foaf/0.1/> . [:a :b] .)
-      serialize(input, nil,
-        [%r(^\s*\[ :a :b\] \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-    
-    it "should generate anon as subject" do
-      input = %(@prefix : <http://xmlns.com/foaf/0.1/> . [:a :b] :c :d .)
-      serialize(input, nil,
-        [%r(^\s*\[ :a :b;$),
-        %r(^\s+:c :d\] \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-    
-    it "should generate anon as object" do
-      input = %(@prefix : <http://xmlns.com/foaf/0.1/> . :a :b [:c :d] .)
-      serialize(input, nil,
-        [%r(^\s*\:a :b \[ :c :d\] \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-  end
-  
-  describe "lists" do
-    it "should generate bare list" do
-      input = %(@prefix : <http://xmlns.com/foaf/0.1/> . (:a :b) .)
-      serialize(input, nil,
-        [%r(^\(:a :b\) \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-
-    it "should generate literal list" do
-      input = %(@prefix : <http://xmlns.com/foaf/0.1/> . :a :b ( "apple" "banana" ) .)
-      serialize(input, nil,
-        [%r(^:a :b \("apple" "banana"\) \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-    
-    it "should generate empty list" do
-      input = %(@prefix : <http://xmlns.com/foaf/0.1/> . :a :b () .)
-      serialize(input, nil,
-        [%r(^:a :b \(\) \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-    
-    it "should generate empty list(2)" do
-      input = %(@prefix : <http://xmlns.com/foaf/0.1/> . :emptyList = () .)
-      serialize(input, nil,
-        [%r(^:emptyList (<.*sameAs>|owl:sameAs) \(\) \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-    
-    it "should generate empty list as subject" do
-      input = %(@prefix : <http://xmlns.com/foaf/0.1/> . () :a :b .)
-      serialize(input, nil,
-        [%r(^\(\) :a :b \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-    
-    it "should generate list as subject" do
-      input = %(@prefix : <http://xmlns.com/foaf/0.1/> . (:a) :b :c .)
-      serialize(input, nil,
-        [%r(^\(:a\) :b :c \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-
-    it "should generate list of empties" do
-      input = %(@prefix : <http://xmlns.com/foaf/0.1/> . :listOf2Empties = (() ()) .)
-      serialize(input, nil,
-        [%r(^:listOf2Empties (<.*sameAs>|owl:sameAs) \(\(\) \(\)\) \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-    
-    it "should generate list anon" do
-      input = %(@prefix : <http://xmlns.com/foaf/0.1/> . :twoAnons = ([a :mother] [a :father]) .)
-      serialize(input, nil,
-        [%r(^:twoAnons (<.*sameAs>|owl:sameAs) \(\[\s*a :mother\] \[\s*a :father\]\) \.$)],
-        :prefixes => { "" => RDF::FOAF}
-      )
-    end
-    
-    it "should generate owl:unionOf list" do
-      input = %(
-        @prefix : <http://xmlns.com/foaf/0.1/> .
-        @prefix owl: <http://www.w3.org/2002/07/owl#> .
-        @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
-        @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
-        :a rdfs:domain [
-          a owl:Class;
-          owl:unionOf [
-            a owl:Class;
-            rdf:first :b;
-            rdf:rest [
-              a owl:Class;
-              rdf:first :c;
-              rdf:rest rdf:nil
-            ]
-          ]
-        ] .
-      )
-      #$verbose = true
-      serialize(input, nil,
-        [
-          %r(:a rdfs:domain \[\s*a owl:Class;\s+owl:unionOf\s+\(:b\s+:c\)\]\s*\.$)m,
-          %r(@prefix : <http://xmlns.com/foaf/0.1/> \.),
-          %r(@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> \.),
-        ],
-        :prefixes => { "" => RDF::FOAF, :rdfs => RDF::RDFS, :owl => RDF::OWL, :rdf => "http://www.w3.org/1999/02/22-rdf-syntax-ns#"}
-      )
-      #$verbose = false
-    end
-  end
-
-  describe "literals" do
-    describe "plain" do
-      it "encodes embedded \"\"\"" do
-        n3 = %(:a :b """testing string parsing in N3.
-  """ .)
-        serialize(n3, nil, [/testing string parsing in N3.\n/])
-      end
-
-      it "encodes embedded \"" do
-        n3 = %(:a :b """string with " escaped quote marks""" .)
-        serialize(n3, nil, [/string with \\" escaped quote mark/])
-      end
-    end
-    
-    describe "with language" do
-      it "specifies language for literal with language" do
-        ttl = %q(:a :b "string"@en .)
-        serialize(ttl, nil, [%r("string"@en)])
-      end
-    end
-    
-    describe "xsd:anyURI" do
-      it "uses xsd namespace for datatype" do
-        ttl = %q(@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . :a :b "http://foo/"^^xsd:anyURI .)
-        serialize(ttl, nil, [
-          %r(@prefix xsd: <http://www.w3.org/2001/XMLSchema#> \.),
-          %r("http://foo/"\^\^xsd:anyURI \.),
-        ])
-      end
-    end
-    
-    describe "xsd:boolean" do
-      [
-        [%q("true"^^xsd:boolean), /true ./],
-        [%q("TrUe"^^xsd:boolean), /true ./],
-        [%q("1"^^xsd:boolean), /true ./],
-        [%q(true), /true ./],
-        [%q("false"^^xsd:boolean), /false ./],
-        [%q("FaLsE"^^xsd:boolean), /false ./],
-        [%q("0"^^xsd:boolean), /false ./],
-        [%q(false), /false ./],
-      ].each do |(l,r)|
-        it "uses token for #{l.inspect}" do
-          ttl = %(@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . :a :b #{l} .)
-          serialize(ttl, nil, [
-            %r(@prefix xsd: <http://www.w3.org/2001/XMLSchema#> \.),
-            r,
-          ], :canonicalize => true)
-        end
-      end
-    end
-    
-    describe "xsd:integer" do
-      [
-        [%q("1"^^xsd:integer), /1 ./],
-        [%q(1), /1 ./],
-        [%q("0"^^xsd:integer), /0 ./],
-        [%q(0), /0 ./],
-        [%q("10"^^xsd:integer), /10 ./],
-        [%q(10), /10 ./],
-      ].each do |(l,r)|
-        it "uses token for #{l.inspect}" do
-          ttl = %(@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . :a :b #{l} .)
-          serialize(ttl, nil, [
-            %r(@prefix xsd: <http://www.w3.org/2001/XMLSchema#> \.),
-            r,
-          ], :canonicalize => true)
-        end
-      end
-    end
-
-    describe "xsd:int" do
-      [
-        [%q("1"^^xsd:int), /"1"\^\^xsd:int ./],
-        [%q("0"^^xsd:int), /"0"\^\^xsd:int ./],
-        [%q("10"^^xsd:int), /"10"\^\^xsd:int ./],
-      ].each do |(l,r)|
-        it "uses token for #{l.inspect}" do
-          ttl = %(@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . :a :b #{l} .)
-          serialize(ttl, nil, [
-            %r(@prefix xsd: <http://www.w3.org/2001/XMLSchema#> \.),
-            r,
-          ], :canonicalize => true)
-        end
-      end
-    end
-
-    describe "xsd:decimal" do
-      [
-        [%q("1.0"^^xsd:decimal), /1.0 ./],
-        [%q(1.0), /1.0 ./],
-        [%q("0.1"^^xsd:decimal), /0.1 ./],
-        [%q(0.1), /0.1 ./],
-        [%q("10.02"^^xsd:decimal), /10.02 ./],
-        [%q(10.02), /10.02 ./],
-      ].each do |(l,r)|
-        it "uses token for #{l.inspect}" do
-          ttl = %(@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . :a :b #{l} .)
-          serialize(ttl, nil, [
-            %r(@prefix xsd: <http://www.w3.org/2001/XMLSchema#> \.),
-            r,
-          ], :canonicalize => true)
-        end
-      end
-    end
-    
-    describe "xsd:double" do
-      [
-        [%q("1.0e1"^^xsd:double), /1.0e1 ./],
-        [%q(1.0e1), /1.0e1 ./],
-        [%q("0.1e1"^^xsd:double), /1.0e0 ./],
-        [%q(0.1e1), /1.0e0 ./],
-        [%q("10.02e1"^^xsd:double), /1.002e2 ./],
-        [%q(10.02e1), /1.002e2 ./],
-      ].each do |(l,r)|
-        it "uses token for #{l.inspect}" do
-          ttl = %(@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . :a :b #{l} .)
-          serialize(ttl, nil, [
-            %r(@prefix xsd: <http://www.w3.org/2001/XMLSchema#> \.),
-            r,
-          ], :canonicalize => true)
-        end
-      end
-    end
-  end
-  
-  # W3C Turtle Test suite from http://www.w3.org/2000/10/swap/test/regression.n3
-  describe "w3c turtle tests" do
-    require 'turtle_test'
-
-    Fixtures::TurtleTest::Good.each do |t|
-      next unless t.comment
-      #puts t.inspect
-      #next unless t.name == "test-04"
-      next if t.name == "test-29" # FIXME
-      
-      specify "#{t.name}: #{t.comment}" do
-        @graph = parse(t.output, :base_uri => t.result, :format => :ntriples)
-        n3 = serialize(t.output, t.result, [], :format => :n3)
-        g2 = parse(n3, :base_uri => t.result)
-        g2.should be_equivalent_graph(@graph, :trace => @debug.join("\n"))
-      end
-    end
-  end
-  
-  def parse(input, options = {})
-    graph = RDF::Graph.new
-    RDF::N3::Reader.new(input, options).each do |statement|
-      graph << statement
-    end
-    graph
-  end
-
-  # Serialize ntstr to a string and compare against regexps
-  def serialize(ntstr, base = nil, regexps = [], options = {})
-    prefixes = options[:prefixes] || {}
-    g = parse(ntstr, :base_uri => base, :prefixes => prefixes)
-    @debug = []
-    result = RDF::N3::Writer.buffer(options.merge(:debug => @debug, :base_uri => base, :prefixes => prefixes)) do |writer|
-      writer << g
-    end
-    if $verbose
-      require 'cgi'
-      #puts CGI.escapeHTML(result)
-    end
-    
-    regexps.each do |re|
-      result.should match_re(re, :about => base, :trace => @debug, :inputDocument => ntstr)
-    end
-    
-    result
-  end
-end