json-ld 3.0.0 → 3.0.1

data/spec/api_spec.rb

@@ -81,17 +81,17 @@ describe JSON::LD::API do
               options = {logger: logger, adapter: adapter}
               options[:expandContext] = File.open(context) if context
               jld = described_class.expand(File.open(filename), options)
-              expect(jld).to produce(JSON.load(File.open(expanded)), logger)
+              expect(jld).to produce_jsonld(JSON.load(File.open(expanded)), logger)
             end if File.exist?(expanded)
         
             it "compacts" do
               jld = described_class.compact(File.open(filename), File.open(context), adapter: adapter, logger: logger)
-              expect(jld).to produce(JSON.load(File.open(compacted)), logger)
+              expect(jld).to produce_jsonld(JSON.load(File.open(compacted)), logger)
             end if File.exist?(compacted) && File.exist?(context)
         
             it "frame" do
               jld = described_class.frame(File.open(filename), File.open(frame), adapter: adapter, logger: logger)
-              expect(jld).to produce(JSON.load(File.open(framed)), logger)
+              expect(jld).to produce_jsonld(JSON.load(File.open(framed)), logger)
             end if File.exist?(framed) && File.exist?(frame)
 
             it "toRdf" do

data/spec/compact_spec.rb

@@ -501,7 +501,7 @@ describe JSON::LD::API do
         })
         allow(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
         jld = JSON::LD::API.compact(input, "http://example.com/context", logger: logger, validate: true)
-        expect(jld).to produce(expected, logger)
+        expect(jld).to produce_jsonld(expected, logger)
       end
     end
 
@@ -2237,7 +2237,12 @@ describe JSON::LD::API do
       expect {JSON::LD::API.compact(input, context, params.merge(logger: logger))}.to raise_error(params[:exception])
     else
       jld = JSON::LD::API.compact(input, context, params.merge(logger: logger))
-      expect(jld).to produce(output, logger)
+      expect(jld).to produce_jsonld(output, logger)
+
+      # Compare expanded jld/output too to make sure list values remain ordered
+      exp_jld = JSON::LD::API.expand(jld, processingMode: 'json-ld-1.1')
+      exp_output = JSON::LD::API.expand(output, processingMode: 'json-ld-1.1')
+      expect(exp_jld).to produce_jsonld(exp_output, logger)
     end
   end
 end

data/spec/expand_spec.rb

@@ -96,6 +96,32 @@ describe JSON::LD::API do
       it(title) {run_expand params}
     end
 
+    context "default language" do
+      {
+        "base": {
+          input: %({
+            "http://example/foo": "bar"
+          }),
+          output: %([{
+            "http://example/foo": [{"@value": "bar", "@language": "en"}]
+          }]),
+          language: "en"
+        },
+        "override": {
+          input: %({
+            "@context": {"@language": null},
+            "http://example/foo": "bar"
+          }),
+          output: %([{
+            "http://example/foo": [{"@value": "bar"}]
+          }]),
+          language: "en"
+        }
+      }.each_pair do |title, params|
+        it(title) {run_expand params}
+      end
+    end
+
     context "with relative IRIs" do
       {
         "base": {
@@ -2349,15 +2375,15 @@ describe JSON::LD::API do
   end
 
   def run_expand(params)
-    input, output, processingMode = params[:input], params[:output], params[:processingMode]
+    input, output = params[:input], params[:output]
     input = ::JSON.parse(input) if input.is_a?(String)
     output = ::JSON.parse(output) if output.is_a?(String)
     pending params.fetch(:pending, "test implementation") unless input
     if params[:exception]
-      expect {JSON::LD::API.expand(input, {processingMode: processingMode}.merge(params))}.to raise_error(params[:exception])
+      expect {JSON::LD::API.expand(input, params)}.to raise_error(params[:exception])
     else
-      jld = JSON::LD::API.expand(input, base: params[:base], logger: logger, processingMode: processingMode)
-      expect(jld).to produce(output, logger)
+      jld = JSON::LD::API.expand(input, {logger: logger}.merge(params))
+      expect(jld).to produce_jsonld(output, logger)
     end
   end
 end

data/spec/flatten_spec.rb

@@ -294,7 +294,7 @@ describe JSON::LD::API do
       expect {JSON::LD::API.flatten(input, context, params.merge(logger: logger))}.to raise_error(params[:exception])
     else
       jld = JSON::LD::API.flatten(input, context, params.merge(logger: logger))
-      expect(jld).to produce(output, logger)
+      expect(jld).to produce_jsonld(output, logger)
     end
   end
 end

data/spec/frame_spec.rb

@@ -652,20 +652,18 @@ describe JSON::LD::API do
             "query": {"@id": "mq:query", "@type": "@id"},
             "result": {"@id": "mf:result", "@type": "xsd:boolean"}
           },
-          "@graph": [{
-            "@type": "mf:Manifest",
-            "comment": "Positive processor tests",
-            "entries": [{
-              "@type": "mf:ManifestEntry",
-              "action": {
-                "@type": "mq:QueryTest",
-                "data": "http://www.w3.org/TR/microdata-rdf/tests/0001.html",
-                "query": "http://www.w3.org/TR/microdata-rdf/tests/0001.ttl"
-              },
-              "comment": "Item with no itemtype and literal itemprop",
-              "mf:result": "true",
-              "name": "Test 0001"
-            }]
+          "@type": "mf:Manifest",
+          "comment": "Positive processor tests",
+          "entries": [{
+            "@type": "mf:ManifestEntry",
+            "action": {
+              "@type": "mq:QueryTest",
+              "data": "http://www.w3.org/TR/microdata-rdf/tests/0001.html",
+              "query": "http://www.w3.org/TR/microdata-rdf/tests/0001.ttl"
+            },
+            "comment": "Item with no itemtype and literal itemprop",
+            "mf:result": "true",
+            "name": "Test 0001"
           }]
         }),
         processingMode: 'json-ld-1.1'
@@ -815,7 +813,7 @@ describe JSON::LD::API do
             frame = ::JSON.parse(frame) if frame.is_a?(String)
             output = ::JSON.parse(output) if output.is_a?(String)
             jld = JSON::LD::API.frame(input, frame, logger: logger)
-            expect(jld).to produce(output, logger)
+            expect(jld).to produce_jsonld(output, logger)
           rescue JSON::LD::JsonLdError => e
             fail("#{e.class}: #{e.message}\n" +
               "#{logger}\n" +
@@ -1129,11 +1127,9 @@ describe JSON::LD::API do
           }),
           output: %({
             "@context": {"@vocab": "urn:"},
-            "@graph": [{
-              "@id": "urn:id-1",
-              "@type": "Class",
-              "preserve": {}
-            }]
+            "@id": "urn:id-1",
+            "@type": "Class",
+            "preserve": {}
           }),
           processingMode: 'json-ld-1.1'
         },
@@ -1157,17 +1153,15 @@ describe JSON::LD::API do
           }),
           output: %({
             "@context": {"@vocab": "urn:"},
-            "@graph": [{
-              "@id": "urn:id-1",
-              "@type": "Class",
-              "preserve": {
-                "@id": "urn:gr-1",
-                "@graph": {
-                  "@id": "urn:id-2",
-                  "term": "data"
-                }
+            "@id": "urn:id-1",
+            "@type": "Class",
+            "preserve": {
+              "@id": "urn:gr-1",
+              "@graph": {
+                "@id": "urn:id-2",
+                "term": "data"
               }
-            }]
+            }
           }),
           processingMode: 'json-ld-1.1'
         },
@@ -1200,21 +1194,19 @@ describe JSON::LD::API do
           }),
           output: %({
             "@context": {"@vocab": "urn:"},
-            "@graph": [{
-              "@id": "urn:id-1",
-              "@type": "Class",
-              "merge": {
-                "@id": "urn:id-2",
-                "term": "foo"
-              },
-              "preserve": {
-                "@id": "urn:graph-1",
-                "@graph": {
-                  "@id": "urn:id-3",
-                  "term": "bar"
-                }
+            "@id": "urn:id-1",
+            "@type": "Class",
+            "merge": {
+              "@id": "urn:id-2",
+              "term": "foo"
+            },
+            "preserve": {
+              "@id": "urn:graph-1",
+              "@graph": {
+                "@id": "urn:id-3",
+                "term": "bar"
               }
-            }]
+            }
           }),
           processingMode: 'json-ld-1.1'
         },
@@ -1250,22 +1242,20 @@ describe JSON::LD::API do
           }),
           output: %({
             "@context": {"@vocab": "urn:"},
-            "@graph": [{
-              "@id": "urn:id-1",
-              "@type": "Class",
-              "merge": {
-                "@id": "urn:id-2",
-                "term": "foo"
-              },
-              "preserve": {
-                "deep": {
-                  "@graph": {
-                    "@id": "urn:id-3",
-                    "term": "bar"
-                  }
+            "@id": "urn:id-1",
+            "@type": "Class",
+            "merge": {
+              "@id": "urn:id-2",
+              "term": "foo"
+            },
+            "preserve": {
+              "deep": {
+                "@graph": {
+                  "@id": "urn:id-3",
+                  "term": "bar"
                 }
               }
-            }]
+            }
           }),
           processingMode: 'json-ld-1.1'
         },
@@ -1301,28 +1291,24 @@ describe JSON::LD::API do
           }),
           output: %({
             "@context": {"@vocab": "http://example.org/"},
-            "@graph": [
-              {
-                "@id": "http://example.org/library",
-                "@type": "Library",
-                "name": "Library",
+            "@id": "http://example.org/library",
+            "@type": "Library",
+            "name": "Library",
+            "contains": {
+              "@id": "http://example.org/graphs/books",
+              "@graph": {
+                "@id": "http://example.org/library/the-republic",
+                "@type": "Book",
+                "creator": "Plato",
+                "title": "The Republic",
                 "contains": {
-                  "@id": "http://example.org/graphs/books",
-                  "@graph": {
-                    "@id": "http://example.org/library/the-republic",
-                    "@type": "Book",
-                    "creator": "Plato",
-                    "title": "The Republic",
-                    "contains": {
-                      "@id": "http://example.org/library/the-republic#introduction",
-                      "@type": "Chapter",
-                      "description": "An introductory chapter on The Republic.",
-                      "title": "The Introduction"
-                    }
-                  }
+                  "@id": "http://example.org/library/the-republic#introduction",
+                  "@type": "Chapter",
+                  "description": "An introductory chapter on The Republic.",
+                  "title": "The Introduction"
                 }
               }
-            ]
+            }
           }),
           processingMode: 'json-ld-1.1'
         }
@@ -1523,14 +1509,10 @@ describe JSON::LD::API do
           },
           "id": "@id"
         },
-        "@graph": [
-          {
-            "claim": {
-              "id": "ex:1",
-              "test": "foo"
-            }
-          }
-        ]
+        "claim": {
+          "id": "ex:1",
+          "test": "foo"
+        }
       })
       do_frame(input: input, frame: frame, output: expected, processingMode: 'json-ld-1.1')
     end
@@ -1708,7 +1690,12 @@ describe JSON::LD::API do
       frame = ::JSON.parse(frame) if frame.is_a?(String)
       output = ::JSON.parse(output) if output.is_a?(String)
       jld = JSON::LD::API.frame(input, frame, logger: logger, processingMode: processingMode)
-      expect(jld).to produce(output, logger)
+      expect(jld).to produce_jsonld(output, logger)
+
+      # Compare expanded jld/output too to make sure list values remain ordered
+      exp_jld = JSON::LD::API.expand(jld, processingMode: 'json-ld-1.1')
+      exp_output = JSON::LD::API.expand(output, processingMode: 'json-ld-1.1')
+      expect(exp_jld).to produce_jsonld(exp_output, logger)
     rescue JSON::LD::JsonLdError => e
       fail("#{e.class}: #{e.message}\n" +
         "#{logger}\n" +

data/spec/from_rdf_spec.rb

@@ -9,7 +9,7 @@ describe JSON::LD::API do
     context "simple tests" do
       it "One subject IRI object" do
         input = %(<http://a/b> <http://a/c> <http://a/d> .)
-        expect(serialize(input)).to produce([
+        expect(serialize(input)).to produce_jsonld([
         {
           '@id'         => "http://a/b",
           "http://a/c"  => [{"@id" => "http://a/d"}]
@@ -20,7 +20,7 @@ describe JSON::LD::API do
       it "should generate object list" do
         input = %(@prefix : <http://example.com/> . :b :c :d, :e .)
         expect(serialize(input)).
-        to produce([{
+        to produce_jsonld([{
           '@id'                         => "http://example.com/b",
           "http://example.com/c" => [
             {"@id" => "http://example.com/d"},
@@ -33,7 +33,7 @@ describe JSON::LD::API do
       it "should generate property list" do
         input = %(@prefix : <http://example.com/> . :b :c :d; :e :f .)
         expect(serialize(input)).
-        to produce([{
+        to produce_jsonld([{
           '@id'   => "http://example.com/b",
           "http://example.com/c"      => [{"@id" => "http://example.com/d"}],
           "http://example.com/e"      => [{"@id" => "http://example.com/f"}]
@@ -49,7 +49,7 @@ describe JSON::LD::API do
           <test-cases/0002> a :TestCase .
         )
         expect(serialize(input)).
-        to produce([
+        to produce_jsonld([
           {'@id'  => "test-cases/0001", '@type' => ["http://www.w3.org/2006/03/test-description#TestCase"]},
           {'@id'  => "test-cases/0002", '@type' => ["http://www.w3.org/2006/03/test-description#TestCase"]},
         ], logger)
@@ -60,7 +60,7 @@ describe JSON::LD::API do
       context "coercion" do
         it "typed literal" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b "foo"^^ex:d .)
-          expect(serialize(input)).to produce([
+          expect(serialize(input)).to produce_jsonld([
             {
               '@id'   => "http://example.com/a",
               "http://example.com/b"    => [{"@value" => "foo", "@type" => "http://example.com/d"}]
@@ -70,7 +70,7 @@ describe JSON::LD::API do
 
         it "integer" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1 .)
-          expect(serialize(input, useNativeTypes: true)).to produce([{
+          expect(serialize(input, useNativeTypes: true)).to produce_jsonld([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => 1}]
           }], logger)
@@ -78,7 +78,7 @@ describe JSON::LD::API do
 
         it "integer (non-native)" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1 .)
-          expect(serialize(input, useNativeTypes: false)).to produce([{
+          expect(serialize(input, useNativeTypes: false)).to produce_jsonld([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => "1","@type" => "http://www.w3.org/2001/XMLSchema#integer"}]
           }], logger)
@@ -86,7 +86,7 @@ describe JSON::LD::API do
 
         it "boolean" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b true .)
-          expect(serialize(input, useNativeTypes: true)).to produce([{
+          expect(serialize(input, useNativeTypes: true)).to produce_jsonld([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => true}]
           }], logger)
@@ -94,7 +94,7 @@ describe JSON::LD::API do
 
         it "boolean (non-native)" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b true .)
-          expect(serialize(input, useNativeTypes: false)).to produce([{
+          expect(serialize(input, useNativeTypes: false)).to produce_jsonld([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => "true","@type" => "http://www.w3.org/2001/XMLSchema#boolean"}]
           }], logger)
@@ -102,7 +102,7 @@ describe JSON::LD::API do
 
         it "decmal" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1.0 .)
-          expect(serialize(input, useNativeTypes: true)).to produce([{
+          expect(serialize(input, useNativeTypes: true)).to produce_jsonld([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => "1.0", "@type" => "http://www.w3.org/2001/XMLSchema#decimal"}]
           }], logger)
@@ -110,7 +110,7 @@ describe JSON::LD::API do
 
         it "double" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1.0e0 .)
-          expect(serialize(input, useNativeTypes: true)).to produce([{
+          expect(serialize(input, useNativeTypes: true)).to produce_jsonld([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => 1.0E0}]
           }], logger)
@@ -118,7 +118,7 @@ describe JSON::LD::API do
 
         it "double (non-native)" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1.0e0 .)
-          expect(serialize(input, useNativeTypes: false)).to produce([{
+          expect(serialize(input, useNativeTypes: false)).to produce_jsonld([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => "1.0E0","@type" => "http://www.w3.org/2001/XMLSchema#double"}]
           }], logger)
@@ -140,7 +140,7 @@ describe JSON::LD::API do
               @prefix ex: <http://example.com/> .
               ex:a ex:b "#{v}"^^xsd:#{t} .
             )
-            expect(serialize(input, useNativeTypes: false)).to produce([{
+            expect(serialize(input, useNativeTypes: false)).to produce_jsonld([{
               '@id'   => "http://example.com/a",
               "http://example.com/b"    => [{"@value" => "#{v}","@type" => "http://www.w3.org/2001/XMLSchema##{t}"}]
             }], logger)
@@ -150,7 +150,7 @@ describe JSON::LD::API do
 
       it "encodes language literal" do
         input = %(@prefix ex: <http://example.com/> . ex:a ex:b "foo"@en-us .)
-        expect(serialize(input)).to produce([{
+        expect(serialize(input)).to produce_jsonld([{
           '@id'   => "http://example.com/a",
           "http://example.com/b"    => [{"@value" => "foo", "@language" => "en-us"}]
         }], logger)
@@ -160,7 +160,7 @@ describe JSON::LD::API do
     context "anons" do
       it "should generate bare anon" do
         input = %(@prefix : <http://example.com/> . _:a :a :b .)
-        expect(serialize(input)).to produce([
+        expect(serialize(input)).to produce_jsonld([
         {
           "@id" => "_:a",
           "http://example.com/a"  => [{"@id" => "http://example.com/b"}]
@@ -170,7 +170,7 @@ describe JSON::LD::API do
     
       it "should generate anon as object" do
         input = %(@prefix : <http://example.com/> . :a :b _:a . _:a :c :d .)
-        expect(serialize(input)).to produce([
+        expect(serialize(input)).to produce_jsonld([
           {
             "@id" => "_:a",
             "http://example.com/c"  => [{"@id" => "http://example.com/d"}]
@@ -185,13 +185,13 @@ describe JSON::LD::API do
 
     context "lists" do
       {
-        "literal list" => [
-          %q(
+        "literal list" => {
+          input: %q(
             @prefix : <http://example.com/> .
             @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
             :a :b ("apple" "banana")  .
           ),
-          [{
+          output: [{
             '@id'   => "http://example.com/a",
             "http://example.com/b"  => [{
               "@list" => [
@@ -200,10 +200,10 @@ describe JSON::LD::API do
               ]
             }]
           }]
-        ],
-        "iri list" => [
-          %q(@prefix : <http://example.com/> . :a :b (:c) .),
-          [{
+        },
+        "iri list" => {
+          input: %q(@prefix : <http://example.com/> . :a :b (:c) .),
+          output: [{
             '@id'   => "http://example.com/a",
             "http://example.com/b"  => [{
               "@list" => [
@@ -211,24 +211,24 @@ describe JSON::LD::API do
               ]
             }]
           }]
-        ],
-        "empty list" => [
-          %q(@prefix : <http://example.com/> . :a :b () .),
-          [{
+        },
+        "empty list" => {
+          input: %q(@prefix : <http://example.com/> . :a :b () .),
+          output: [{
             '@id'   => "http://example.com/a",
             "http://example.com/b"  => [{"@list" => []}]
           }]
-        ],
-        "single element list" => [
-          %q(@prefix : <http://example.com/> . :a :b ( "apple" ) .),
-          [{
+        },
+        "single element list" => {
+          input: %q(@prefix : <http://example.com/> . :a :b ( "apple" ) .),
+          output: [{
             '@id'   => "http://example.com/a",
             "http://example.com/b"  => [{"@list" => [{"@value" => "apple"}]}]
           }]
-        ],
-        "single element list without @type" => [
-          %q(@prefix : <http://example.com/> . :a :b ( _:a ) . _:a :b "foo" .),
-          [
+        },
+        "single element list without @type" => {
+          input: %q(@prefix : <http://example.com/> . :a :b ( _:a ) . _:a :b "foo" .),
+          output: [
             {
               '@id'   => "_:a",
               "http://example.com/b"  => [{"@value" => "foo"}]
@@ -238,9 +238,9 @@ describe JSON::LD::API do
               "http://example.com/b"  => [{"@list" => [{"@id" => "_:a"}]}]
             },
           ]
-        ],
-        "multiple graphs with shared BNode" => [
-          %q(
+        },
+        "multiple graphs with shared BNode" => {
+          input: %q(
             <http://www.example.com/z> <http://www.example.com/q> _:z0 <http://www.example.com/G> .
             _:z0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "cell-A" <http://www.example.com/G> .
             _:z0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:z1 <http://www.example.com/G> .
@@ -248,7 +248,7 @@ describe JSON::LD::API do
             _:z1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> <http://www.example.com/G> .
             <http://www.example.com/x> <http://www.example.com/p> _:z1 <http://www.example.com/G1> .
           ),
-          [{
+          output: [{
             "@id" => "http://www.example.com/G",
             "@graph" => [{
               "@id" => "_:z0",
@@ -270,10 +270,10 @@ describe JSON::LD::API do
               "http://www.example.com/p" => [{"@id" => "_:z1"}]
             }]
           }],
-          RDF::NQuads::Reader
-        ],
-        "multiple graphs with shared BNode (at head)" => [
-          %q(
+          reader: RDF::NQuads::Reader
+        },
+        "multiple graphs with shared BNode (at head)" => {
+          input: %q(
             <http://www.example.com/z> <http://www.example.com/q> _:z0 <http://www.example.com/G> .
             _:z0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "cell-A" <http://www.example.com/G> .
             _:z0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:z1 <http://www.example.com/G> .
@@ -281,7 +281,7 @@ describe JSON::LD::API do
             _:z1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> <http://www.example.com/G> .
             <http://www.example.com/z> <http://www.example.com/q> _:z0 <http://www.example.com/G1> .
           ),
-          [{
+          output: [{
             "@id" => "http://www.example.com/G",
             "@graph" => [{
               "@id" => "_:z0",
@@ -299,33 +299,33 @@ describe JSON::LD::API do
               "http://www.example.com/q" => [{"@id" => "_:z0"}]
             }]
           }],
-          RDF::NQuads::Reader
-        ],
-        "@list containing empty @list" => [
-          %(
+          reader: RDF::NQuads::Reader
+        },
+        "@list containing empty @list" => {
+          input: %(
             <http://example.com/a> <http://example.com/property> (()) .
           ),
-          JSON.parse(%([{
+          output: %([{
             "@id": "http://example.com/a",
             "http://example.com/property": [{"@list": [{"@list": []}]}]
-          }])),
-          RDF::Turtle::Reader
-        ],
-        "@list containing multiple lists" => [
-          %(
+          }]),
+          reader: RDF::Turtle::Reader
+        },
+        "@list containing multiple lists" => {
+          input: %(
             <http://example.com/a> <http://example.com/property> (("a") ("b")) .
           ),
-          JSON.parse(%([{
+          output: %([{
             "@id": "http://example.com/a",
             "http://example.com/property": [{"@list": [
               {"@list": [{"@value": "a"}]},
               {"@list": [{"@value": "b"}]}
             ]}]
-          }])),
-          RDF::Turtle::Reader
-        ],
-        "0008a" => [
-          %(
+          }]),
+          reader: RDF::Turtle::Reader
+        },
+        "0008a" => {
+          input: %(
           <http://example.com> <http://example.com/property> _:outerlist .
           _:outerlist <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> _:lista .
           _:outerlist <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:b0 .
@@ -355,7 +355,7 @@ describe JSON::LD::API do
           _:b3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "b3" .
           _:b3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
           ),
-          JSON.parse(%([
+          output: JSON.parse(%([
             {
               "@id": "http://example.com",
               "http://example.com/property": [
@@ -369,12 +369,11 @@ describe JSON::LD::API do
               ]
             }
           ])),
-          RDF::NQuads::Reader
-        ]
-      }.each do |name, (input, output, reader)|
-        it name do
-          r = serialize(input, reader: reader)
-          expect(r).to produce(output, logger)
+          reader: RDF::NQuads::Reader
+        }
+      }.each do |name, params|
+        it "#{name}" do
+          do_fromRdf(params)
         end
       end
     end
@@ -465,33 +464,32 @@ describe JSON::LD::API do
             }
           ]
         },
-      }.each_pair do |name, properties|
-        it name do
-          r = serialize(properties[:input], reader: RDF::NQuads::Reader)
-          expect(r).to produce(properties[:output], logger)
+      }.each_pair do |name, params|
+        it "#{name}" do
+          do_fromRdf(params.merge(reader: RDF::NQuads::Reader))
         end
       end
     end
   
     context "problems" do
       {
-        "xsd:boolean as value" => [
-          %(
+        "xsd:boolean as value" => {
+          input: %(
             @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
             @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
 
             <http://data.wikia.com/terms#playable> rdfs:range xsd:boolean .
           ),
-          [{
+          output: [{
             "@id" => "http://data.wikia.com/terms#playable",
             "http://www.w3.org/2000/01/rdf-schema#range" => [
               { "@id" => "http://www.w3.org/2001/XMLSchema#boolean" }
             ]
           }]
-        ],
-      }.each do |t, (input, output)|
+        },
+      }.each do |t, params|
         it "#{t}" do
-          expect(serialize(input)).to produce(output, logger)
+          do_fromRdf(params)
         end
       end
     end
@@ -510,4 +508,17 @@ describe JSON::LD::API do
     statements = g.each_statement.to_a
     JSON::LD::API.fromRdf(statements, logger: logger, **options)
   end
+
+  def do_fromRdf(params)
+    begin
+      input, output, processingMode = params[:input], params[:output], params.fetch(:processingMode, 'json-ld-1.0')
+      output = ::JSON.parse(output) if output.is_a?(String)
+      jld = serialize(input, **params)
+      expect(jld).to produce_jsonld(output, logger)
+    rescue JSON::LD::JsonLdError => e
+      fail("#{e.class}: #{e.message}\n" +
+        "#{logger}\n" +
+        "Backtrace:\n#{e.backtrace.join("\n")}")
+    end
+  end
 end