gkellogg-reddy 0.2.1

data/spec/graph_spec.rb

@@ -0,0 +1,390 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Graphs" do
+  before(:all) do
+    @ex = Namespace.new("http://example.org/", "ex")
+    @foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    @bn_ctx = {}
+  end
+  
+  subject { Graph.new(:store => ListStore.new) }
+  it "should allow you to add one or more triples" do
+    lambda do
+      subject.add_triple(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+    end.should_not raise_error
+  end
+  
+  it "should support << as an alias for add_triple" do
+    lambda do
+      subject << Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+    end.should_not raise_error
+    subject.size.should == 1
+  end
+  
+  it "should return bnode subjects" do
+    bn = BNode.new
+    subject.add_triple(bn, URIRef.new("http://xmlns.com/foaf/0.1/knows"), bn)
+    subject.subjects.should == [bn]
+  end
+  
+  it "should be able to determine whether or not it has existing BNodes" do
+    foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    john = BNode.new('john', @bn_ctx)
+    jane = BNode.new('jane', @bn_ctx)
+    jack = BNode.new('jack', @bn_ctx)
+    
+    subject << Triple.new(john, foaf.knows, jane)
+    subject.has_bnode_identifier?(john).should be_true
+    subject.has_bnode_identifier?(jane).should be_true
+    subject.has_bnode_identifier?(jack).should_not be_true
+  end
+  
+  it "should allow you to create and bind Namespace objects" do
+    subject.bind(Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")).should be_a(Namespace)
+    subject.nsbinding["foaf"].uri.should == "http://xmlns.com/foaf/0.1/"
+  end
+  
+  it "should bind namespace" do
+    foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    subject.bind(foaf).should == foaf
+  end
+  
+  it "should not allow you to bind things other than namespaces" do
+    lambda do
+      subject.bind(false)
+    end.should raise_error
+  end
+    
+  it "should follow the specification as to output identical triples" do
+    subject.add_triple(@ex.a, @ex.b, @ex.c)
+    subject.add_triple(@ex.a, @ex.b, @ex.c)
+    subject.size.should == 1
+  end
+  
+  it "should parse into existing graph" do
+    n3_string = "<http://example.org/> <http://xmlns.com/foaf/0.1/name> \"Gregg Kellogg\" . "
+    graph = subject.parse(n3_string, nil, :type => :n3)
+    graph.should == subject
+    graph.identifier.should be_a(BNode)
+    subject.size.should == 1
+    subject[0].subject.to_s.should == "http://example.org/"
+    subject[0].predicate.to_s.should == "http://xmlns.com/foaf/0.1/name"
+    subject[0].object.to_s.should == "Gregg Kellogg"
+  end
+  
+  it "should add multiple triples" do
+    subject.add(Triple.new(@ex.a, @ex.b, @ex.c), Triple.new(@ex.a, @ex.b, @ex.d))
+    subject.size.should == 2
+  end
+
+  describe "with identifier" do
+    before(:all) { @identifier = URIRef.new("http://foo.bar") }
+    subject { Graph.new(:identifier => @identifier) }
+    
+    it "should retrieve identifier" do
+      subject.identifier.should == @identifier
+      subject.identifier.should == @identifier.to_s
+    end
+  end
+  
+  describe "with named store" do
+    before(:all) do
+      @identifier = URIRef.new("http://foo.bar")
+      @store = ListStore.new(:identifier => @identifier)
+    end
+    
+    subject {
+      g = Graph.new(:identifier => @identifier, :store => @store)
+      g.add_triple(@ex.john, @foaf.knows, @ex.jane)
+      g.add_triple(@ex.john, @foaf.knows, @ex.rick)
+      g.add_triple(@ex.jane, @foaf.knows, @ex.rick)
+      g.bind(@foaf)
+      g
+    }
+    
+    it "should retrieve identifier" do
+      subject.identifier.should == @identifier
+      subject.identifier.should == @identifier.to_s
+    end
+    
+    it "should be same as graph with same store and identifier" do
+      g = Graph.new(:store => @store)
+      subject.should == g
+    end
+  end
+  
+  describe "with XML Literal objects" do
+    subject {
+      dc = Namespace.new("http://purl.org/dc/elements/1.1/", "dc")
+      xhtml = Namespace.new("http://www.w3.org/1999/xhtml", "")
+      g = Graph.new(:store => ListStore.new)
+      g << Triple.new(
+        URIRef.new("http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml"),
+        URIRef.new("http://purl.org/dc/elements/1.1/title"),
+        Literal.typed("E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">2</sup>: The Most Urgent Problem of Our Time",
+                      "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                      g.nsbinding)
+      )
+      g.bind(dc)
+      g.bind(xhtml)
+      g
+    }
+    
+    it "should output NTriple" do
+      nt = '<http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml> <http://purl.org/dc/elements/1.1/title> "E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">2</sup>: The Most Urgent Problem of Our Time"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral> .' + "\n"
+      subject.to_ntriples.should == nt
+    end
+
+    it "should output RDF/XML" do
+      rdfxml = <<-HERE
+<?xml version="1.0" encoding="UTF-8"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:xml=\"http://www.w3.org/XML/1998/namespace\" xmlns:rdfs=\"http://www.w3.org/2000/01/rdf-schema#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:xhv=\"http://www.w3.org/1999/xhtml/vocab#\">
+  <rdf:Description rdf:about="http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml">
+    <dc:title rdf:parseType="Literal">E = mc<sup xmlns="http://www.w3.org/1999/xhtml" xmlns:dc="http://purl.org/dc/elements/1.1/">2>/sup>: The Most Urgent Problem of Our Time</dc:title>
+  </rdf:Description>
+</rdf:RDF>
+HERE
+      subject.to_rdfxml.should include("E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">2</sup>: The Most Urgent Problem of Our Time")
+    end
+  end
+  
+  describe "with bnodes" do
+    subject {
+      g = Graph.new(:store => ListStore.new)
+      a = BNode.new("a")
+      b = BNode.new("b")
+      
+      g << Triple.new(a, @foaf.name, Literal.untyped("Manu Sporny"))
+      g << Triple.new(a, @foaf.knows, b)
+      g << Triple.new(b, @foaf.name, Literal.untyped("Ralph Swick"))
+      g.bind(@foaf)
+      g
+    }
+    
+    it "should return bnodes" do
+      subject.bnodes.keys.length.should == 2
+      subject.bnodes.values.should == [2, 2]
+    end
+
+    it "should output RDF/XML" do
+      rdfxml = <<-HERE
+<?xml version="1.0" encoding="utf-8"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:xhv="http://www.w3.org/1999/xhtml/vocab#">
+  <rdf:Description rdf:nodeID="a">
+    <foaf:name>Manu Sporny</foaf:name>
+    <foaf:knows rdf:nodeID="b"/>
+  </rdf:Description>
+  <rdf:Description rdf:nodeID="b">
+    <foaf:name>Ralph Swick</foaf:name>
+  </rdf:Description>
+</rdf:RDF>
+HERE
+      xml = subject.to_rdfxml
+      xml.should include("Ralph Swick")
+      xml.should include("Manu Sporny")
+    end
+  end
+  
+  describe "with triples" do
+    subject {
+      g = Graph.new(:store => ListStore.new)
+      g.add_triple(@ex.john, @foaf.knows, @ex.jane)
+      g.add_triple(@ex.john, @foaf.knows, @ex.rick)
+      g.add_triple(@ex.jane, @foaf.knows, @ex.rick)
+      g.bind(@foaf)
+      g
+    }
+
+    it "should detect included triple" do
+      subject.contains?(subject[0]).should be_true
+    end
+    
+    it "should tell you how large the graph is" do
+      subject.size.should == 3
+    end
+  
+    it "should return unique subjects" do
+      subject.subjects.should == [@ex.john.uri.to_s, @ex.jane.uri.to_s]
+    end
+    
+    it "should return unique predicates" do
+      subject.predicates.should == [@foaf.knows.uri.to_s]
+    end
+    
+    it "should return unique objects" do
+      subject.objects.should == [@ex.jane.uri.to_s, @ex.rick.uri.to_s]
+    end
+    
+    it "should allow you to select resources" do
+      subject.triples(Triple.new(@ex.john, nil, nil)).size.should == 2
+    end
+
+    it "should allow iteration" do
+      count = 0
+      subject.triples do |t|
+        count = count + 1
+        t.class.should == Triple
+      end
+      count.should == 3
+    end
+
+    it "should allow iteration over a particular subject" do
+      count = 0
+      subject.triples(Triple.new(@ex.john, nil, nil)) do |t|
+        count = count + 1
+        t.class.should == Triple
+        t.subject.should == @ex.john
+      end
+      count.should == 2
+    end
+
+    it "should give you a list of resources of a particular type" do
+      subject.add_triple(@ex.john, RDF_TYPE, @foaf.Person)
+      subject.add_triple(@ex.jane, RDF_TYPE, @foaf.Person)
+
+      subject.get_by_type("http://xmlns.com/foaf/0.1/Person").should == [@ex.john, @ex.jane]
+    end
+    
+    it "should remove a triple" do
+      subject.add(Triple.new(@ex.john, RDF_TYPE, @foaf.Person))
+      subject.size.should == 4
+      subject.remove(Triple.new(@ex.john, RDF_TYPE, @foaf.Person))
+      subject.size.should == 3
+    end
+
+    it "should remove all triples" do
+      subject.remove(Triple.new(nil, nil, nil))
+      subject.size.should == 0
+    end
+
+    describe "find triples" do
+      it "should find subjects" do
+        subject.triples(Triple.new(@ex.john, nil, nil)).size.should == 2
+        subject.triples(Triple.new(@ex.jane, nil, nil)).size.should == 1
+      end
+      
+      it "should find predicates" do
+        subject.triples(Triple.new(nil, @foaf.knows, nil)).size.should == 3
+      end
+      
+      it "should find objects" do
+        subject.triples(Triple.new(nil, nil, @ex.rick)).size.should == 2
+      end
+      
+      it "should find object with regexp" do
+        subject.triples(Triple.new(nil, nil, @ex.rick)).size.should == 2
+      end
+      
+      it "should find combinations" do
+        subject.triples(Triple.new(@ex.john, nil, @ex.rick)).size.should == 1
+      end
+    end
+    
+    describe "encodings" do
+      it "should output NTriple" do
+        nt = "<http://example.org/john> <http://xmlns.com/foaf/0.1/knows> <http://example.org/jane> .\n<http://example.org/john> <http://xmlns.com/foaf/0.1/knows> <http://example.org/rick> .\n<http://example.org/jane> <http://xmlns.com/foaf/0.1/knows> <http://example.org/rick> .\n"
+        subject.to_ntriples.should == nt
+      end
+    
+      it "should output RDF/XML" do
+        rdfxml = <<HERE
+<?xml version="1.0" encoding="UTF-8"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:xhv="http://www.w3.org/1999/xhtml/vocab#">
+  <rdf:Description rdf:about="http://example.org/john">
+    <foaf:knows rdf:resource="http://example.org/jane"/>
+  </rdf:Description>
+  <rdf:Description rdf:about="http://example.org/john">
+    <foaf:knows rdf:resource="http://example.org/rick"/>
+  </rdf:Description>
+  <rdf:Description rdf:about="http://example.org/jane">
+    <foaf:knows rdf:resource="http://example.org/rick"/>
+  </rdf:Description>
+</rdf:RDF>
+HERE
+        subject.to_rdfxml.should be_equivalent_xml(rdfxml)
+      end
+    end
+  end
+
+  describe "which are merged" do
+    it "should be able to integrate another graph" do
+      subject.add_triple(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+      g = Graph.new(:store => ListStore.new)
+      g.merge!(subject)
+      g.size.should == 1
+    end
+    
+    it "should not merge with non graph" do
+      lambda do
+        h.merge!("")
+      end.should raise_error
+    end
+    
+    # One does not, in general, obtain the merge of a set of graphs by concatenating their corresponding
+    # N-Triples documents and constructing the graph described by the merged document. If some of the
+    # documents use the same node identifiers, the merged document will describe a graph in which some of the
+    # blank nodes have been 'accidentally' identified. To merge N-Triples documents it is necessary to check
+    # if the same nodeID is used in two or more documents, and to replace it with a distinct nodeID in each
+    # of them, before merging the documents.
+    it "should remap bnodes to avoid duplicate bnode identifiers" do
+      subject.add_triple(BNode.new("a1", @bn_ctx), URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new("a2", @bn_ctx))
+      g = Graph.new(:store => ListStore.new)
+      g.add_triple(BNode.new("a1", @bn_ctx), URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new("a2", @bn_ctx))
+      g.merge!(subject)
+      g.size.should == 2
+      s1, s2 = g.triples.map(&:subject)
+      p1, p2 = g.triples.map(&:predicate)
+      o1, o2 = g.triples.map(&:object)
+      s1.should_not == s2
+      p1.should == p1
+      o1.should_not == o2
+    end
+
+    it "should remove duplicate triples" do
+      subject.add_triple(@ex.a, URIRef.new("http://xmlns.com/foaf/0.1/knows"), @ex.b)
+      g = Graph.new(:store => ListStore.new)
+      g.add_triple(@ex.a, URIRef.new("http://xmlns.com/foaf/0.1/knows"), @ex.b)
+      g.merge!(subject)
+      g.size.should == 1
+    end
+  end
+  
+  describe "that can be compared" do
+    {
+      "ListStore" => :list_store,
+      "MemoryStore" => :memory_store
+    }.each_pair do |t, s|
+      describe "using #{t}" do
+        subject { Graph.new(:store => s)}
+        
+        it "should be true for empty graphs" do
+          subject.should == Graph.new(:store => s)
+        end
+
+        it "should be false for different graphs" do
+          f = Graph.new(:store => s)
+          f.add_triple(URIRef.new("http://example.org/joe"), URIRef.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), URIRef.new("http://xmlns.com/foaf/0.1/Person"))
+          subject.should_not == f
+        end
+    
+        it "should be true for equivalent graphs with different BNode identifiers" do
+          subject.add_triple(@ex.a, @foaf.knows, BNode.new("a1", @bn_ctx))
+          subject.add_triple(BNode.new("a1", @bn_ctx), @foaf.knows, @ex.a)
+
+          f = Graph.new(:store => s)
+          f.add_triple(@ex.a, @foaf.knows, BNode.new("a2", @bn_ctx))
+          f.add_triple(BNode.new("a2", @bn_ctx), @foaf.knows, @ex.a)
+          subject.should == f
+        end
+    
+        it "should be true for graphs with literals" do
+          subject.add_triple(@ex.a, @foaf.knows, Literal.untyped("foo"))
+
+          f = Graph.new(:store => s)
+          f.add_triple(@ex.a, @foaf.knows, Literal.untyped("foo"))
+          subject.should == f
+        end
+      end
+    end
+  end
+end

data/spec/literal_spec.rb

@@ -0,0 +1,314 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Literals: " do
+  describe "an untyped string" do
+    subject {Literal.untyped("tom")}
+    it "should be equal if they have the same contents" do should == Literal.untyped("tom") end
+    it "should not be equal if they do not have the same contents" do should_not == Literal.untyped("tim") end
+    it "should match a string" do should == "tom" end
+    it "should return a string using to_s" do subject.to_s.should == "tom" end
+    
+    it "should infer type" do
+      other = Literal.build_from("foo")
+      other.encoding.should == "http://www.w3.org/2001/XMLSchema#string"
+    end
+    
+    describe "should handle specific cases" do
+      {
+        '"Gregg"' => Literal.untyped("Gregg"),
+        '"\u677E\u672C \u540E\u5B50"' => Literal.untyped("松本 后子"),
+        '"D\u00FCrst"' => Literal.untyped("Dürst")
+      }.each_pair do |encoded, literal|
+        it "should encode '#{literal.contents}'" do
+          literal.to_n3.should == encoded
+        end
+      end
+    end
+
+    describe "encodings" do
+      it "should return n3" do subject.to_n3.should == "\"tom\"" end
+      it "should return ntriples" do subject.to_ntriples.should == "\"tom\"" end
+      it "should return xml_args" do subject.xml_args.should == ["tom", {}] end
+      it "should return TriX" do subject.to_trix.should == "<plainLiteral>tom</plainLiteral>" end
+    end
+
+    describe "with extended characters" do
+      subject { Literal.untyped("松本 后子") }
+      
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == '"\u677E\u672C \u540E\u5B50"' end
+        it "should return ntriples" do subject.to_ntriples.should == '"\u677E\u672C \u540E\u5B50"' end
+        it "should return xml_args" do subject.xml_args.should == ["松本 后子", {}] end
+        it "should return TriX" do subject.to_trix.should == "<plainLiteral>" + "松本 后子" + "</plainLiteral>" end
+      end
+    end
+    
+    describe "with a language" do
+      subject { Literal.untyped("tom", "en") }
+
+      it "should accept a language tag" do
+        subject.lang.should == "en"
+      end
+  
+      it "should be equal if they have the same contents and language" do
+        should == Literal.untyped("tom", "en")
+      end
+  
+      it "should not be equal if they do not have the same contents" do
+        should_not == Literal.untyped("tim", "en")
+      end
+    
+      it "should not be equal if they do not have the same language" do
+        should_not == Literal.untyped("tom", "fr")
+      end
+
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == "\"tom\"@en" end
+        it "should return ntriples" do subject.to_ntriples.should == "\"tom\"@en" end
+        it "should return xml_args" do subject.xml_args.should == ["tom", {"xml:lang" => "en"}] end
+        it "should return TriX" do subject.to_trix.should == "<plainLiteral xml:lang=\"en\">tom</plainLiteral>" end
+      end
+
+      it "should normalize language tags to lower case" do
+        f = Literal.untyped("tom", "EN")
+        f.lang.should == "en"
+      end
+    end
+  end
+  
+  describe "a typed string" do
+    subject { Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#string") }
+    
+    it "accepts an encoding" do
+      subject.encoding.to_s.should == "http://www.w3.org/2001/XMLSchema#string"
+    end
+
+    it "should be equal if they have the same contents and datatype" do
+      should == Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#string")
+    end
+
+    it "should not be equal if they do not have the same contents" do
+      should_not == Literal.typed("tim", "http://www.w3.org/2001/XMLSchema#string")
+    end
+
+    it "should not be equal if they do not have the same datatype" do
+      should_not == Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#token")
+    end
+
+    describe "encodings" do
+      it "should return n3" do subject.to_n3.should == "\"tom\"^^<http://www.w3.org/2001/XMLSchema#string>" end
+      it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+      it "should return xml_args" do subject.xml_args.should == ["tom", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#string"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#string\">tom</typedLiteral>" end
+    end
+  end
+  
+  describe "an integer" do
+    describe "encodings" do
+      subject { Literal.typed(5, "http://www.w3.org/2001/XMLSchema#int") }
+      it "should return n3" do subject.to_n3.should == "\"5\"^^<http://www.w3.org/2001/XMLSchema#int>" end
+      it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+      it "should return xml_args" do subject.xml_args.should == ["5", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#int"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#int\">5</typedLiteral>" end
+    end
+
+    it "should infer type" do
+      int = Literal.build_from(15)
+      int.encoding.should == "http://www.w3.org/2001/XMLSchema#int"
+    end
+  end
+    
+  describe "a float" do
+    describe "encodings" do
+      subject { Literal.typed(15.4, "http://www.w3.org/2001/XMLSchema#float") }
+      it "should return n3" do subject.to_n3.should == "\"15.4\"^^<http://www.w3.org/2001/XMLSchema#float>" end
+      it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+      it "should return xml_args" do subject.xml_args.should == ["15.4", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#float"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#float\">15.4</typedLiteral>" end
+    end
+
+    it "should infer type" do
+      float = Literal.build_from(15.4)
+      float.encoding.should == "http://www.w3.org/2001/XMLSchema#float"
+    end
+  end
+    
+  describe "XML Literal" do
+    describe "with no namespace" do
+      subject { Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral") }
+      it "should indicate xmlliteral?" do
+        subject.xmlliteral?.should == true
+      end
+      
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == "\"foo <sup>bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+        it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+        it "should return xml_args" do subject.xml_args.should == ["foo <sup>bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
+        it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup>bar</sup> baz!</typedLiteral>" end
+      end
+      
+      it "should be equal if they have the same contents" do
+        should == Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+      end
+
+      it "should be a XMLLiteral encoding" do
+        subject.encoding.should == "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"
+      end
+    end
+      
+    describe "with a namespace" do
+      subject {
+        Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                      :namespaces => {"dc" => Namespace.new("http://purl.org/dc/elements/1.1/", "dc")})
+      }
+    
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == "\"foo <sup>bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+        it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+        it "should return xml_args" do subject.xml_args.should == ["foo <sup>bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
+        it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup>bar</sup> baz!</typedLiteral>" end
+      end
+      
+      describe "and language" do
+        subject {
+          Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                        :namespaces => {"dc" => Namespace.new("http://purl.org/dc/elements/1.1/", "dc")},
+                        :language => "fr")
+        }
+
+        describe "encodings" do
+          it "should return n3" do subject.to_n3.should == "\"foo <sup xml:lang=\\\"fr\\\">bar</sup> baz!\"\^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+          it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+          it "should return xml_args" do subject.xml_args.should == ["foo <sup xml:lang=\"fr\">bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
+          it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup xml:lang=\"fr\">bar</sup> baz!</typedLiteral>" end
+        end
+      end
+      
+      describe "and language with an existing language embedded" do
+        subject {
+          Literal.typed("foo <sup>bar</sup><sub xml:lang=\"en\">baz</sub>",
+                        "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                        :language => "fr")
+        }
+
+        describe "encodings" do
+          it "should return n3" do subject.to_n3.should == "\"foo <sup xml:lang=\\\"fr\\\">bar</sup><sub xml:lang=\\\"en\\\">baz</sub>\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+          it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+          it "should return xml_args" do subject.xml_args.should == ["foo <sup xml:lang=\"fr\">bar</sup><sub xml:lang=\"en\">baz</sub>", {"rdf:parseType" => "Literal"}] end
+          it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup xml:lang=\"fr\">bar</sup><sub xml:lang=\"en\">baz</sub></typedLiteral>" end
+        end
+      end
+      
+      describe "and namespaced element" do
+        subject {
+          root = Nokogiri::XML.parse(%(
+          <?xml version="1.0" encoding="UTF-8"?>
+          <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">
+          <html xmlns="http://www.w3.org/1999/xhtml"
+                xmlns:dc="http://purl.org/dc/elements/1.1/"
+          	  xmlns:ex="http://example.org/rdf/"
+          	  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+          	  xmlns:svg="http://www.w3.org/2000/svg">
+          	<head profile="http://www.w3.org/1999/xhtml/vocab http://www.w3.org/2005/10/profile">
+          		<title>Test 0100</title>
+          	</head>
+            <body>
+            	<div about="http://www.example.org">
+                <h2 property="ex:example" datatype="rdf:XMLLiteral"><svg:svg/></h2>
+          	</div>
+            </body>
+          </html>
+          ), nil, nil, Nokogiri::XML::ParseOptions::DEFAULT_XML).root
+          content = root.css("h2").children
+          Literal.typed(content,
+                        "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                        :namespaces => {
+                          "svg" => Namespace.new("http://www.w3.org/2000/svg", "svg"),
+                          "dc" => Namespace.new("http://purl.org/dc/elements/1.1/", "dc")
+                        })
+        }
+        it "should return xml_args" do subject.xml_args.should == ["<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"></svg:svg>", {"rdf:parseType" => "Literal"}] end
+      end
+      
+      describe "and existing namespace definition" do
+        subject {
+          Literal.typed("<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"/>",
+                        "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                        :namespaces => {"svg" => Namespace.new("http://www.w3.org/2000/svg", "svg")})
+        }
+        it "should return xml_args" do subject.xml_args.should == ["<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"></svg:svg>", {"rdf:parseType" => "Literal"}] end
+      end
+    end
+      
+    describe "with a default namespace" do
+      subject {
+        Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                      :namespaces => {"" => Namespace.new("http://purl.org/dc/elements/1.1/", "")})
+      }
+    
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == "\"foo <sup xmlns=\\\"http://purl.org/dc/elements/1.1/\\\">bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+        it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+        it "should return xml_args" do subject.xml_args.should == ["foo <sup xmlns=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
+        it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup xmlns=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!</typedLiteral>" end
+      end
+    end
+    
+    describe "with multiple namespaces" do
+      subject {
+        Literal.typed("foo <sup <sup xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+      }
+      it "should ignore namespace order" do
+        g = Literal.typed("foo <sup <sup xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+        should == g
+      end
+    end
+    
+    describe "with multiple attributes" do
+      it "should ignore attribute order" do
+        f = Literal.typed("foo <sup a=\"a\" b=\"b\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+        g = Literal.typed("foo <sup b=\"b\" a=\"a\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+        f.should == g
+      end
+    end
+  end
+  
+  describe "an n3 literal" do
+    {
+      "Gregg" => ['Gregg', nil, nil],
+      "Dürst" => ['D\u00FCrst', nil, nil],
+      "simple literal"  => ['simple literal', nil, nil],
+      "backslash:\\" => ['backslash:\\\\', nil, nil],
+      "dquote:\"" => ['dquote:\\"', nil, nil],
+      "newline:\n" => ['newline:\\n', nil, nil],
+      "return:\r" => ['return:\\r', nil, nil],
+      "tab:\t" => ['tab:\\t', nil, nil],
+    }.each_pair do |name, args|
+      specify "test #{name}" do
+        Literal.n3_encoded(*args).contents.should == name
+      end
+    end
+  end
+  
+#  it "build_from_language" do
+#    english = Literal.build_from_language("Have a nice day")
+#    english.encoding.should == "en"
+#    
+#    french = Literal.build_from_language("Bonjour, madame. Parlez vous francais?")
+#    french.encoding.should == "fr"
+#    
+#    german = Literal.build_from_language("Achtung")
+#    german.encoding.should == "de"
+#  end
+
+  # TODO: refactor based on new interface
+  # describe "Languages" do
+  #   it "should be inspectable" do
+  #     literal = Reddy::Literal.new("foo", "en")
+  #     lang = literal.lang
+  #     lang.to_s == "en"
+  #     lang.hash.class.should == Fixnum
+  #   end    
+  # end
+  
+end