json-ld 2.1.2 → 2.1.3

data/spec/context_spec.rb

@@ -24,7 +24,7 @@ end
 
 describe JSON::LD::Context do
   let(:logger) {RDF::Spec.logger}
-  let(:context) {JSON::LD::Context.new(logger: logger, validate: true)}
+  let(:context) {JSON::LD::Context.new(logger: logger, validate: true, processingMode: "json-ld-1.1")}
   let(:remote_doc) do
     JSON::LD::API::RemoteDocument.new("http://example.com/context", %q({
       "@context": {
@@ -98,7 +98,7 @@ describe JSON::LD::Context do
         let(:ctx) {["http://example.com/context", {"integer" => "xsd:integer"}]}
         it "retrieves and parses a remote context document" do
           expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
-          ec = subject.parse(ctx)
+          subject.parse(ctx)
         end
 
         it "does not use passed context as provided_context" do
@@ -112,13 +112,13 @@ describe JSON::LD::Context do
         let(:ctx) {"http://example.com/preloaded"}
         before(:all) {
           JSON::LD::Context.add_preloaded("http://example.com/preloaded",
-          JSON::LD::Context.new().parse({'foo' => "http://example.com/"})
+          JSON::LD::Context.parse({'foo' => "http://example.com/"})
         )}
         after(:all) {JSON::LD::Context::PRELOADED.clear}
 
         it "does not load referenced context" do
           expect(JSON::LD::API).not_to receive(:documentLoader).with(ctx, anything)
-          ec = subject.parse(ctx)
+          subject.parse(ctx)
         end
 
         it "uses loaded context" do
@@ -192,7 +192,7 @@ describe JSON::LD::Context do
         }, logger)
       end
 
-      it "associates @list container mapping with predicate" do
+      it "associates @list container mapping with term" do
         expect(subject.parse({
           "foo" => {"@id" => "http://example.com/", "@container" => "@list"}
         }).containers).to produce({
@@ -200,7 +200,7 @@ describe JSON::LD::Context do
         }, logger)
       end
 
-      it "associates @set container mapping with predicate" do
+      it "associates @set container mapping with term" do
         expect(subject.parse({
           "foo" => {"@id" => "http://example.com/", "@container" => "@set"}
         }).containers).to produce({
@@ -208,7 +208,23 @@ describe JSON::LD::Context do
         }, logger)
       end
 
-      it "associates @id container mapping with predicate" do
+      it "associates @type container mapping with term" do
+        expect(subject.parse({
+          "foo" => {"@id" => "http://example.com/", "@container" => "@type"}
+        }).containers).to produce({
+          "foo" => "@type"
+        }, logger)
+      end
+
+      it "associates @id container mapping with term" do
+        expect(subject.parse({
+          "foo" => {"@id" => "http://example.com/", "@container" => "@id"}
+        }).containers).to produce({
+          "foo" => "@id"
+        }, logger)
+      end
+
+      it "associates @id type mapping with term" do
         expect(subject.parse({
           "foo" => {"@id" => "http://example.com/", "@type" => "@id"}
         }).coercions).to produce({
@@ -216,7 +232,7 @@ describe JSON::LD::Context do
         }, logger)
       end
 
-      it "associates type mapping with predicate" do
+      it "associates type mapping with term" do
         expect(subject.parse({
           "foo" => {"@id" => "http://example.com/", "@type" => RDF::XSD.string.to_s}
         }).coercions).to produce({
@@ -224,7 +240,7 @@ describe JSON::LD::Context do
         }, logger)
       end
 
-      it "associates language mapping with predicate" do
+      it "associates language mapping with term" do
         expect(subject.parse({
           "foo" => {"@id" => "http://example.com/", "@language" => "en"}
         }).send(:languages)).to produce({
@@ -316,6 +332,7 @@ describe JSON::LD::Context do
         "@container as object" => {"foo" => {"@container" => {}}},
         "@container as array" => {"foo" => {"@container" => []}},
         "@container as string" => {"foo" => {"@container" => "true"}},
+        "@context which is invalid" => {"foo" => {"@context" => {"bar" => []}}},
         "@language as @id" => {"@language" => {"@id" => "http://example.com/"}},
         "@vocab as @id" => {"@vocab" => {"@id" => "http://example.com/"}},
       }.each do |title, context|
@@ -345,9 +362,50 @@ describe JSON::LD::Context do
     end
   end
 
+  describe "#processingMode" do
+    it "sets to json-ld-1.0 if not specified" do
+      [
+        %({}),
+        %([{}]),
+      ].each do |str|
+        ctx = JSON::LD::Context.parse(::JSON.parse(str))
+        expect(ctx.processingMode).to eql "json-ld-1.0"
+      end
+    end
+
+    it "sets to json-ld-1.1 if @version: 1.1" do
+      [
+        %({"@version": 1.1}),
+        %([{"@version": 1.1}]),
+      ].each do |str|
+        ctx = JSON::LD::Context.parse(::JSON.parse(str))
+        expect(ctx.processingMode).to eql "json-ld-1.1"
+      end
+    end
+
+    it "raises InvalidVersionValue if @version out of scope" do
+      [
+        "1.1",
+        "1.0",
+        1.0,
+        "foo"
+      ].each do |vers|
+        expect {JSON::LD::Context.parse({"@version" => vers})}.to raise_error(JSON::LD::JsonLdError::InvalidVersionValue)
+      end
+    end
+
+    it "raises ProcessingModeConflict if provided processing mode conflicts with context" do
+      expect {JSON::LD::Context.parse({"@version" => 1.1}, processingMode: "json-ld-1.0")}.to raise_error(JSON::LD::JsonLdError::ProcessingModeConflict)
+    end
+
+    it "raises ProcessingModeConflict nested context is different from starting context" do
+      expect {JSON::LD::Context.parse([{}, {"@version" => 1.1}])}.to raise_error(JSON::LD::JsonLdError::ProcessingModeConflict)
+    end
+  end
+
   describe "#merge" do
     it "creates a new context with components of each" do
-      c2 = JSON::LD::Context.new().parse({'foo' => "http://example.com/"})
+      c2 = JSON::LD::Context.parse({'foo' => "http://example.com/"})
       cm = context.merge(c2)
       expect(cm).not_to equal context
       expect(cm).not_to equal c2
@@ -357,7 +415,7 @@ describe JSON::LD::Context do
 
   describe "#merge!" do
     it "updates context with components from new" do
-      c2 = JSON::LD::Context.new().parse({'foo' => "http://example.com/"})
+      c2 = JSON::LD::Context.parse({'foo' => "http://example.com/"})
       cm = context.merge!(c2)
       expect(cm).to equal context
       expect(cm).not_to equal c2
@@ -414,6 +472,20 @@ describe JSON::LD::Context do
       expect(c.to_rb).not_to be_empty
     end
 
+    it "@context" do
+      expect(subject.parse({
+        "foo" => {"@id" => "http://example.com/", "@context" => {"bar" => "http://example.com/baz"}}
+      }).send(:clear_provided_context).
+      serialize).to produce({
+        "@context" => {
+          "foo" => {
+            "@id" => "http://example.com/",
+            "@context" => {"bar" => "http://example.com/baz"}
+          }
+        }
+      }, logger)
+    end
+
     it "@type with dependent prefixes in a single context" do
       expect(subject.parse({
         'xsd' => "http://www.w3.org/2001/XMLSchema#",
@@ -648,8 +720,7 @@ describe JSON::LD::Context do
         }
       }.each do |title, params|
         it title do
-          ec = subject.parse(params[:input])
-          expect(ec.serialize).to produce(params[:result], logger)
+          expect {subject.parse(params[:input])}.to raise_error(JSON::LD::JsonLdError::InvalidTermDefinition)
         end
       end
     end
@@ -902,11 +973,11 @@ describe JSON::LD::Context do
             [{"@value" => "foo"}, {"@value" => "bar"}, {"@value" => 1}],
             [{"@value" => "de", "@language" => "de"}, {"@value" => "jp", "@language" => "jp"}],
             [{"@value" => true}], [{"@value" => false}], 
-            [[{"@value" => 1}], [{"@value" => 1.1}], 
+            [{"@value" => 1}], [{"@value" => 1.1}],
           ],
           "listlang" => [[{"@value" => "en", "@language" => "en"}]],
           "listbool" => [[{"@value" => "true", "@type" => RDF::XSD.boolean.to_s}]],
-          "listinteger" => [{"@value" => "1", "@type" => RDF::XSD.integer.to_s}]],
+          "listinteger" => [[{"@value" => "1", "@type" => RDF::XSD.integer.to_s}]],
           "listdouble" => [[{"@value" => "1", "@type" => RDF::XSD.double.to_s}]],
           "listdate" => [[{"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}]],
         }.each do |prop, values|
@@ -1284,26 +1355,43 @@ describe JSON::LD::Context do
   describe "#container" do
     subject {
       ctx = context.parse({
-        "ex" => "http://example.org/",
-        "list" => {"@id" => "ex:list", "@container" => "@list"},
-        "set" => {"@id" => "ex:set", "@container" => "@set"},
-        "ndx" => {"@id" => "ex:ndx", "@container" => "@index"},
+        "ex"       => "http://example.org/",
+        "list"     => {"@id" => "ex:list", "@container" => "@list"},
+        "set"      => {"@id" => "ex:set", "@container" => "@set"},
+        "language" => {"@id" => "ex:language", "@container" => "@language"},
+        "ndx"      => {"@id" => "ex:ndx", "@container" => "@index"},
+        "id"       => {"@id" => "ex:id", "@container" => "@id"},
+        "type"     => {"@id" => "ex:type", "@container" => "@type"}
       })
       logger.clear
       ctx
     }
     it "uses TermDefinition" do
-      expect(subject.container(subject.term_definitions['ex'])).to be_nil
-      expect(subject.container(subject.term_definitions['list'])).to eq '@list'
-      expect(subject.container(subject.term_definitions['set'])).to eq '@set'
-      expect(subject.container(subject.term_definitions['ndx'])).to eq '@index'
+      {
+        "ex"       => nil,
+        "list"     => "@list",
+        "set"      => "@set",
+        "language" => "@language",
+        "ndx"      => "@index",
+        "id"       => "@id",
+        "type"     => "@type",
+      }.each do |defn, container|
+        expect(subject.container(subject.term_definitions[defn])).to eq container
+      end
     end
 
     it "uses string" do
-      expect(subject.container('ex')).to be_nil
-      expect(subject.container('list')).to eq '@list'
-      expect(subject.container('set')).to eq '@set'
-      expect(subject.container('ndx')).to eq '@index'
+      {
+        "ex"       => nil,
+        "list"     => "@list",
+        "set"      => "@set",
+        "language" => "@language",
+        "ndx"      => "@index",
+        "id"       => "@id",
+        "type"     => "@type",
+      }.each do |defn, container|
+        expect(subject.container(defn)).to eq container
+      end
     end
   end
 
@@ -1350,6 +1438,44 @@ describe JSON::LD::Context do
     end
   end
 
+  describe "#nest" do
+    subject {
+      ctx = context.parse({
+        "ex"          => "http://example.org/",
+        "nest"        => {"@id" => "ex:nest", "@nest" => "@nest"},
+        "nest2"       => {"@id" => "ex:nest2", "@nest" => "nest-alias"},
+        "nest-alias"  => "@nest"
+      })
+      logger.clear
+      ctx
+    }
+
+    it "uses term" do
+      {
+        "ex"       => nil,
+        "nest"     => "@nest",
+        "nest2"      => "nest-alias",
+        "nest-alias"  => nil,
+      }.each do |defn, nest|
+        expect(subject.nest(defn)).to eq nest
+      end
+    end
+
+    context "detects error" do
+      it "does not allow a keyword other than @nest for the value of @nest" do
+        expect {
+          context.parse({"no-keyword-nest" => {"@id" => "http://example/f", "@nest" => "@id"}})
+        }.to raise_error JSON::LD::JsonLdError::InvalidNestValue
+      end
+
+      it "does not allow @nest with @reverse" do
+        expect {
+          context.parse({"no-reverse-nest" => {"@reverse" => "http://example/f", "@nest" => "@nest"}})
+        }.to raise_error JSON::LD::JsonLdError::InvalidReverseProperty
+      end
+    end
+  end
+
   describe "#reverse_term" do
     subject {
       ctx = context.parse({

data/spec/expand_spec.rb

@@ -85,10 +85,7 @@ describe JSON::LD::API do
         output: [{"http://example.com/ex" => [{"@value" => false}]}]
       }
     }.each_pair do |title, params|
-      it title do
-        jld = JSON::LD::API.expand(params[:input], logger: logger)
-        expect(jld).to produce(params[:output], logger)
-      end
+      it(title) {run_expand params}
     end
 
     context "with relative IRIs" do
@@ -96,31 +93,31 @@ describe JSON::LD::API do
         "base" => {
           input: {
             "@id" => "",
-            "@type" => "#{RDF::RDFS.Resource}"
+            "@type" => "http://www.w3.org/2000/01/rdf-schema#Resource"
           },
           output: [{
             "@id" => "http://example.org/",
-            "@type" => ["#{RDF::RDFS.Resource}"]
+            "@type" => ["http://www.w3.org/2000/01/rdf-schema#Resource"]
           }]
         },
         "relative" => {
           input: {
             "@id" => "a/b",
-            "@type" => "#{RDF::RDFS.Resource}"
+            "@type" => "http://www.w3.org/2000/01/rdf-schema#Resource"
           },
           output: [{
             "@id" => "http://example.org/a/b",
-            "@type" => ["#{RDF::RDFS.Resource}"]
+            "@type" => ["http://www.w3.org/2000/01/rdf-schema#Resource"]
           }]
         },
         "hash" => {
           input: {
             "@id" => "#a",
-            "@type" => "#{RDF::RDFS.Resource}"
+            "@type" => "http://www.w3.org/2000/01/rdf-schema#Resource"
           },
           output: [{
             "@id" => "http://example.org/#a",
-            "@type" => ["#{RDF::RDFS.Resource}"]
+            "@type" => ["http://www.w3.org/2000/01/rdf-schema#Resource"]
           }]
         },
         "unmapped @id" => {
@@ -132,10 +129,7 @@ describe JSON::LD::API do
           }]
         },
       }.each do |title, params|
-        it title do
-          jld = JSON::LD::API.expand(params[:input], base: "http://example.org/", logger: logger)
-          expect(jld).to produce(params[:output], logger)
-        end
+        it(title) {run_expand params.merge(base: "http://example.org/")}
       end
     end
 
@@ -145,21 +139,21 @@ describe JSON::LD::API do
           input: {
             "@context" => {"id" => "@id"},
             "id" => "",
-            "@type" => "#{RDF::RDFS.Resource}"
+            "@type" => "http://www.w3.org/2000/01/rdf-schema#Resource"
           },
           output: [{
             "@id" => "",
-            "@type" =>[ "#{RDF::RDFS.Resource}"]
+            "@type" =>[ "http://www.w3.org/2000/01/rdf-schema#Resource"]
           }]
         },
         "@type" => {
           input: {
             "@context" => {"type" => "@type"},
-            "type" => RDF::RDFS.Resource.to_s,
+            "type" => "http://www.w3.org/2000/01/rdf-schema#Resource",
             "http://example.com/foo" => {"@value" => "bar", "type" => "http://example.com/baz"}
           },
           output: [{
-            "@type" => [RDF::RDFS.Resource.to_s],
+            "@type" => ["http://www.w3.org/2000/01/rdf-schema#Resource"],
             "http://example.com/foo" => [{"@value" => "bar", "@type" => "http://example.com/baz"}]
           }]
         },
@@ -191,10 +185,7 @@ describe JSON::LD::API do
           }]
         },
       }.each do |title, params|
-        it title do
-          jld = JSON::LD::API.expand(params[:input], logger: logger)
-          expect(jld).to produce(params[:output], logger)
-        end
+        it(title) {run_expand params}
       end
     end
 
@@ -246,10 +237,7 @@ describe JSON::LD::API do
           }]
         },
       }.each do |title, params|
-        it title do
-          jld = JSON::LD::API.expand(params[:input], logger: logger)
-          expect(jld).to produce(params[:output], logger)
-        end
+        it(title) {run_expand params}
       end
     end
 
@@ -257,27 +245,24 @@ describe JSON::LD::API do
       {
         "boolean" => {
           input: {
-            "@context" => {"foo" => {"@id" => "http://example.org/foo", "@type" => RDF::XSD.boolean.to_s}},
+            "@context" => {"foo" => {"@id" => "http://example.org/foo", "@type" => "http://www.w3.org/2001/XMLSchema#boolean"}},
             "foo" => "true"
           },
           output: [{
-            "http://example.org/foo" => [{"@value" => "true", "@type" => RDF::XSD.boolean.to_s}]
+            "http://example.org/foo" => [{"@value" => "true", "@type" => "http://www.w3.org/2001/XMLSchema#boolean"}]
           }]
         },
         "date" => {
           input: {
-            "@context" => {"foo" => {"@id" => "http://example.org/foo", "@type" => RDF::XSD.date.to_s}},
+            "@context" => {"foo" => {"@id" => "http://example.org/foo", "@type" => "http://www.w3.org/2001/XMLSchema#date"}},
             "foo" => "2011-03-26"
           },
           output: [{
-            "http://example.org/foo" => [{"@value" => "2011-03-26", "@type" => RDF::XSD.date.to_s}]
+            "http://example.org/foo" => [{"@value" => "2011-03-26", "@type" => "http://www.w3.org/2001/XMLSchema#date"}]
           }]
         },
       }.each do |title, params|
-        it title do
-          jld = JSON::LD::API.expand(params[:input], logger: logger)
-          expect(jld).to produce(params[:output], logger)
-        end
+        it(title) {run_expand params}
       end
     end
 
@@ -318,10 +303,7 @@ describe JSON::LD::API do
           }]
         }
       }.each do |title, params|
-        it title do
-          jld = JSON::LD::API.expand(params[:input], logger: logger)
-          expect(jld).to produce(params[:output], logger)
-        end
+        it(title) {run_expand params}
       end
     end
 
@@ -346,10 +328,7 @@ describe JSON::LD::API do
           ]
         },
       }.each do |title, params|
-        it title do
-          jld = JSON::LD::API.expand(params[:input], logger: logger)
-          expect(jld).to produce(params[:output], logger)
-        end
+        it(title) {run_expand params}
       end
     end
 
@@ -412,12 +391,7 @@ describe JSON::LD::API do
           ]
         }
       }.each do |title, params|
-        it title do
-          jld = JSON::LD::API.expand(params[:input],
-            base: "http://foo/bar/",
-            logger: logger)
-          expect(jld).to produce(params[:output], logger)
-        end
+        it(title) {run_expand params.merge(base: "http://foo/bar/")}
       end
     end
 
@@ -469,14 +443,43 @@ describe JSON::LD::API do
           }
         ]}
       }.each do |title, params|
-        it title do
-          jld = JSON::LD::API.expand(params[:input], logger: logger, base: 'http://example/')
-          expect(jld).to produce(params[:output], logger)
-        end
+        it(title) {run_expand params.merge(base: "http://example/")}
+      end
+    end
+
+    context "@container: @index" do
+      {
+        "string annotation" => {
+          input: {
+            "@context" => {
+              "container" => {
+                "@id" => "http://example.com/container",
+                "@container" => "@index"
+              }
+            },
+            "@id" => "http://example.com/annotationsTest",
+            "container" => {
+              "en" => "The Queen",
+              "de" => [ "Die Königin", "Ihre Majestät" ]
+            }
+          },
+          output: [
+            {
+              "@id" => "http://example.com/annotationsTest",
+              "http://example.com/container" => [
+                {"@value" => "Die Königin", "@index" => "de"},
+                {"@value" => "Ihre Majestät", "@index" => "de"},
+                {"@value" => "The Queen", "@index" => "en"}
+              ]
+            }
+          ]
+        },
+      }.each do |title, params|
+        it(title) {run_expand params}
       end
     end
 
-    context "lists" do
+    context "@container: @list" do
       {
         "empty" => {
           input: {"http://example.com/foo" => {"@list" => []}},
@@ -505,6 +508,14 @@ describe JSON::LD::API do
             "http://example.com/foo" => [{"@list" => [ {"@value" => "foo"}, {"@value" => "bar"} ]}]
           }]
         },
+        "native values in list" => {
+          input: {
+            "http://example.com/foo" => {"@list" => [1, 2]}
+          },
+          output: [{
+            "http://example.com/foo" => [{"@list" => [{"@value" => 1}, {"@value" => 2}]}]
+          }]
+        },
         "explicit list with coerced @id values" => {
           input: {
             "@context" => {"http://example.com/foo" => {"@type" => "@id"}},
@@ -524,7 +535,7 @@ describe JSON::LD::API do
           }]
         },
         "expand-0004" => {
-          input: ::JSON.parse(%({
+          input: %({
             "@context": {
               "mylist1": {"@id": "http://example.com/mylist1", "@container": "@list"},
               "mylist2": {"@id": "http://example.com/mylist2", "@container": "@list"},
@@ -532,8 +543,8 @@ describe JSON::LD::API do
               "myset3": {"@id": "http://example.com/myset3", "@container": "@set"}
             },
             "http://example.org/property": { "@list": "one item" }
-          })),
-          output: ::JSON.parse(%([
+          }),
+          output: %([
             {
               "http://example.org/property": [
                 {
@@ -545,17 +556,34 @@ describe JSON::LD::API do
                 }
               ]
             }
-          ]))
-        }
+          ])
+        },
+        "@list containing @list" => {
+          input: {
+            "http://example.com/foo" => {"@list" => [{"@list" => ["baz"]}]}
+          },
+          exception: JSON::LD::JsonLdError::ListOfLists
+        },
+        "@list containing @list (with coercion)" => {
+          input: {
+            "@context" => {"foo" => {"@id" => "http://example.com/foo", "@container" => "@list"}},
+            "foo" => [{"@list" => ["baz"]}]
+          },
+          exception: JSON::LD::JsonLdError::ListOfLists
+        },
+        "coerced @list containing an array" => {
+          input: {
+            "@context" => {"foo" => {"@id" => "http://example.com/foo", "@container" => "@list"}},
+            "foo" => [["baz"]]
+          },
+          exception: JSON::LD::JsonLdError::ListOfLists
+        },
       }.each do |title, params|
-        it title do
-          jld = JSON::LD::API.expand(params[:input], logger: logger)
-          expect(jld).to produce(params[:output], logger)
-        end
+        it(title) {run_expand params}
       end
     end
 
-    context "sets" do
+    context "@container: @set" do
       {
         "empty" => {
           input: {
@@ -601,14 +629,11 @@ describe JSON::LD::API do
           }]
         },
       }.each do |title, params|
-        it title do
-          jld = JSON::LD::API.expand(params[:input], logger: logger)
-          expect(jld).to produce(params[:output], logger)
-        end
+        it(title) {run_expand params}
       end
     end
 
-    context "language maps" do
+    context "@container: @language" do
       {
         "simple map" => {
           input: {
@@ -669,17 +694,795 @@ describe JSON::LD::API do
           ]
         }
       }.each do |title, params|
-        it title do
-          jld = JSON::LD::API.expand(params[:input], logger: logger)
-          expect(jld).to produce(params[:output], logger)
-        end
+        it(title) {run_expand params}
+      end
+    end
+
+    context "@container: @id" do
+      {
+        "Adds @id to object not having an @id" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "idmap": {"@container": "@id"}
+            },
+            "idmap": {
+              "http://example.org/foo": {"label": "Object with @id <foo>"},
+              "_:bar": {"label": "Object with @id _:bar"}
+            }
+          }),
+          output: %([{
+            "http://example/idmap": [
+              {"http://example/label": [{"@value": "Object with @id _:bar"}], "@id": "_:bar"},
+              {"http://example/label": [{"@value": "Object with @id <foo>"}], "@id": "http://example.org/foo"}
+            ]
+          }])
+        },
+        "Retains @id in object already having an @id" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "idmap": {"@container": "@id"}
+            },
+            "idmap": {
+              "http://example.org/foo": {"@id": "http://example.org/bar", "label": "Object with @id <foo>"},
+              "_:bar": {"@id": "_:foo", "label": "Object with @id _:bar"}
+            }
+          }),
+          output: %([{
+            "http://example/idmap": [
+              {"@id": "_:foo", "http://example/label": [{"@value": "Object with @id _:bar"}]},
+              {"@id": "http://example.org/bar", "http://example/label": [{"@value": "Object with @id <foo>"}]}
+            ]
+          }])
+        },
+        "Adds expanded @id to object" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "idmap": {"@container": "@id"}
+            },
+            "idmap": {
+              "foo": {"label": "Object with @id <foo>"}
+            }
+          }),
+          output: %([{
+            "http://example/idmap": [
+              {"http://example/label": [{"@value": "Object with @id <foo>"}], "@id": "http://example.org/foo"}
+            ]
+          }]),
+          base: "http://example.org/"
+        },
+        "Raises InvalidContainerMapping if processingMode is not specified" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "idmap": {"@container": "@id"}
+            },
+            "idmap": {
+              "http://example.org/foo": {"label": "Object with @id <foo>"},
+              "_:bar": {"label": "Object with @id _:bar"}
+            }
+          }),
+          processingMode: nil,
+          exception: JSON::LD::JsonLdError::InvalidContainerMapping
+        },
+      }.each do |title, params|
+        it(title) {run_expand({processingMode: "json-ld-1.1"}.merge(params))}
+      end
+    end
+
+    context "@container: @type" do
+      {
+        "Adds @type to object not having an @type" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "typemap": {"@container": "@type"}
+            },
+            "typemap": {
+              "http://example.org/foo": {"label": "Object with @type <foo>"},
+              "_:bar": {"label": "Object with @type _:bar"}
+            }
+          }),
+          output: %([{
+            "http://example/typemap": [
+              {"http://example/label": [{"@value": "Object with @type _:bar"}], "@type": ["_:bar"]},
+              {"http://example/label": [{"@value": "Object with @type <foo>"}], "@type": ["http://example.org/foo"]}
+            ]
+          }])
+        },
+        "Prepends @type in object already having an @type" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "typemap": {"@container": "@type"}
+            },
+            "typemap": {
+              "http://example.org/foo": {"@type": "http://example.org/bar", "label": "Object with @type <foo>"},
+              "_:bar": {"@type": "_:foo", "label": "Object with @type _:bar"}
+            }
+          }),
+          output: %([{
+            "http://example/typemap": [
+              {
+                "@type": ["_:bar", "_:foo"],
+                "http://example/label": [{"@value": "Object with @type _:bar"}]
+              },
+              {
+                "@type": ["http://example.org/foo", "http://example.org/bar"],
+                "http://example/label": [{"@value": "Object with @type <foo>"}]
+              }
+            ]
+          }])
+        },
+        "Adds vocabulary expanded @type to object" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "typemap": {"@container": "@type"}
+            },
+            "typemap": {
+              "Foo": {"label": "Object with @type <foo>"}
+            }
+          }),
+          output: %([{
+            "http://example/typemap": [
+              {"http://example/label": [{"@value": "Object with @type <foo>"}], "@type": ["http://example/Foo"]}
+            ]
+          }])
+        },
+        "Adds document expanded @type to object" => {
+          input: %({
+            "@context": {
+              "typemap": {"@id": "http://example/typemap", "@container": "@type"},
+              "label": "http://example/label"
+            },
+            "typemap": {
+              "Foo": {"label": "Object with @type <foo>"}
+            }
+          }),
+          output: %([{
+            "http://example/typemap": [
+              {"http://example/label": [{"@value": "Object with @type <foo>"}], "@type": ["http://example.org/Foo"]}
+            ]
+          }]),
+          base: "http://example.org/"
+        },
+        "Raises InvalidContainerMapping if processingMode is not specified" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "typemap": {"@container": "@type"}
+            },
+            "typemap": {
+              "http://example.org/foo": {"label": "Object with @type <foo>"},
+              "_:bar": {"label": "Object with @type _:bar"}
+            }
+          }),
+          processingMode: nil,
+          exception: JSON::LD::JsonLdError::InvalidContainerMapping
+        },
+      }.each do |title, params|
+        it(title) {run_expand({processingMode: "json-ld-1.1"}.merge(params))}
+      end
+    end
+
+    context "@nest" do
+      {
+        "Expands input using @nest" => {
+          input: %({
+            "@context": {"@vocab": "http://example.org/"},
+            "p1": "v1",
+            "@nest": {
+              "p2": "v2"
+            }
+          }),
+          output: %([{
+            "http://example.org/p1": [{"@value": "v1"}],
+            "http://example.org/p2": [{"@value": "v2"}]
+          }])
+        },
+        "Expands input using aliased @nest" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "nest": "@nest"
+            },
+            "p1": "v1",
+            "nest": {
+              "p2": "v2"
+            }
+          }),
+          output: %([{
+            "http://example.org/p1": [{"@value": "v1"}],
+            "http://example.org/p2": [{"@value": "v2"}]
+          }])
+        },
+        "Appends nested values when property at base and nested" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "nest": "@nest"
+            },
+            "p1": "v1",
+            "nest": {
+              "p2": "v3"
+            },
+            "p2": "v2"
+          }),
+          output: %([{
+            "http://example.org/p1": [{"@value": "v1"}],
+            "http://example.org/p2": [
+              {"@value": "v2"},
+              {"@value": "v3"}
+            ]
+          }])
+        },
+        "Appends nested values from all @nest aliases in term order" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "nest1": "@nest",
+              "nest2": "@nest"
+            },
+            "p1": "v1",
+            "nest2": {
+              "p2": "v4"
+            },
+            "p2": "v2",
+            "nest1": {
+              "p2": "v3"
+            }
+          }),
+          output: %([{
+            "http://example.org/p1": [{"@value": "v1"}],
+            "http://example.org/p2": [
+              {"@value": "v2"},
+              {"@value": "v3"},
+              {"@value": "v4"}
+            ]
+          }])
+        },
+        "Nested nested containers" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example.org/"
+            },
+            "p1": "v1",
+            "@nest": {
+              "p2": "v3",
+              "@nest": {
+                "p2": "v4"
+              }
+            },
+            "p2": "v2"
+          }),
+          output: %([{
+            "http://example.org/p1": [{"@value": "v1"}],
+            "http://example.org/p2": [
+              {"@value": "v2"},
+              {"@value": "v3"},
+              {"@value": "v4"}
+            ]
+          }])
+        },
+        "Arrays of nested values" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "nest": "@nest"
+            },
+            "p1": "v1",
+            "nest": {
+              "p2": ["v4", "v5"]
+            },
+            "p2": ["v2", "v3"]
+          }),
+          output: %([{
+            "http://example.org/p1": [{"@value": "v1"}],
+            "http://example.org/p2": [
+              {"@value": "v2"},
+              {"@value": "v3"},
+              {"@value": "v4"},
+              {"@value": "v5"}
+            ]
+          }])
+        },
+        "A nest of arrays" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "nest": "@nest"
+            },
+            "p1": "v1",
+            "nest": [{
+              "p2": "v4"
+            }, {
+              "p2": "v5"
+            }],
+            "p2": ["v2", "v3"]
+          }),
+          output: %([{
+            "http://example.org/p1": [{"@value": "v1"}],
+            "http://example.org/p2": [
+              {"@value": "v2"},
+              {"@value": "v3"},
+              {"@value": "v4"},
+              {"@value": "v5"}
+            ]
+          }])
+        },
+        "@nest MUST NOT have a string value" => {
+          input: %({
+            "@context": {"@vocab": "http://example.org/"},
+            "@nest": "This should generate an error"
+          }),
+          exception: JSON::LD::JsonLdError::InvalidNestValue
+        },
+        "@nest MUST NOT have a boolen value" => {
+          input: %({
+            "@context": {"@vocab": "http://example.org/"},
+            "@nest": true
+          }),
+          exception: JSON::LD::JsonLdError::InvalidNestValue
+        },
+        "@nest MUST NOT have a numeric value" => {
+          input: %({
+            "@context": {"@vocab": "http://example.org/"},
+            "@nest": 1
+          }),
+          exception: JSON::LD::JsonLdError::InvalidNestValue
+        },
+        "@nest MUST NOT have a value object value" => {
+          input: %({
+            "@context": {"@vocab": "http://example.org/"},
+            "@nest": {"@value": "This should generate an error"}
+          }),
+          exception: JSON::LD::JsonLdError::InvalidNestValue
+        },
+        "@nest in term definition MUST NOT be a non-@nest keyword" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "nest": {"@nest": "@id"}
+            },
+            "nest": "This should generate an error"
+          }),
+          exception: JSON::LD::JsonLdError::InvalidNestValue
+        },
+        "@nest in term definition MUST NOT have a boolen value" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "nest": {"@nest": true}
+            },
+            "nest": "This should generate an error"
+          }),
+          exception: JSON::LD::JsonLdError::InvalidNestValue
+        },
+        "@nest in term definition MUST NOT have a numeric value" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "nest": {"@nest": 123}
+            },
+            "nest": "This should generate an error"
+          }),
+          exception: JSON::LD::JsonLdError::InvalidNestValue
+        },
+        "Nested @container: @list" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "list": {"@container": "@list", "@nest": "nestedlist"},
+              "nestedlist": "@nest"
+            },
+            "nestedlist": {
+              "list": ["a", "b"]
+            }
+          }),
+          output: %([{
+            "http://example.org/list": [{"@list": [
+              {"@value": "a"},
+              {"@value": "b"}
+            ]}]
+          }])
+        },
+        "Nested @container: @index" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "index": {"@container": "@index", "@nest": "nestedindex"},
+              "nestedindex": "@nest"
+            },
+            "nestedindex": {
+              "index": {
+                "A": "a",
+                "B": "b"
+              }
+            }
+          }),
+          output: %([{
+            "http://example.org/index": [
+              {"@value": "a", "@index": "A"},
+              {"@value": "b", "@index": "B"}
+            ]
+          }])
+        },
+        "Nested @container: @language" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "container": {"@container": "@language", "@nest": "nestedlanguage"},
+              "nestedlanguage": "@nest"
+            },
+            "nestedlanguage": {
+              "container": {
+                "en": "The Queen",
+                "de": "Die Königin"
+              }
+            }
+          }),
+          output: %([{
+            "http://example.org/container": [
+              {"@value": "Die Königin", "@language": "de"},
+              {"@value": "The Queen", "@language": "en"}
+            ]
+          }])
+        },
+        "Nested @container: @type" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "typemap": {"@container": "@type", "@nest": "nestedtypemap"},
+              "nestedtypemap": "@nest"
+            },
+            "nestedtypemap": {
+              "typemap": {
+                "http://example.org/foo": {"label": "Object with @type <foo>"},
+                "_:bar": {"label": "Object with @type _:bar"}
+              }
+            }
+          }),
+          output: %([{
+            "http://example/typemap": [
+              {"http://example/label": [{"@value": "Object with @type _:bar"}], "@type": ["_:bar"]},
+              {"http://example/label": [{"@value": "Object with @type <foo>"}], "@type": ["http://example.org/foo"]}
+            ]
+          }])
+        },
+        "Nested @container: @id" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "idmap": {"@container": "@id", "@nest": "nestedidmap"},
+              "nestedidmap": "@nest"
+            },
+            "nestedidmap": {
+              "idmap": {
+                "http://example.org/foo": {"label": "Object with @id <foo>"},
+                "_:bar": {"label": "Object with @id _:bar"}
+              }
+            }
+          }),
+          output: %([{
+            "http://example/idmap": [
+              {"http://example/label": [{"@value": "Object with @id _:bar"}], "@id": "_:bar"},
+              {"http://example/label": [{"@value": "Object with @id <foo>"}], "@id": "http://example.org/foo"}
+            ]
+          }])
+        },
+        "Nest term an invalid keyword" => {
+          input: %({
+            "@context": {
+              "term": {"@id": "http://example/term", "@nest": "@id"}
+            }
+          }),
+          exception: JSON::LD::JsonLdError::InvalidNestValue
+        },
+        "Nest in @reverse" => {
+          input: %({
+            "@context": {
+              "term": {"@reverse": "http://example/term", "@nest": "@nest"}
+            }
+          }),
+          exception: JSON::LD::JsonLdError::InvalidReverseProperty
+        },
+        "Raises InvalidTermDefinition if processingMode is not specified" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "list": {"@container": "@list", "@nest": "nestedlist"},
+              "nestedlist": "@nest"
+            },
+            "nestedlist": {
+              "list": ["a", "b"]
+            }
+          }),
+          processingMode: nil,
+          exception: JSON::LD::JsonLdError::InvalidTermDefinition
+        },
+      }.each do |title, params|
+        it(title) {run_expand({processingMode: "json-ld-1.1"}.merge(params))}
+      end
+    end
+
+    context "scoped context" do
+      {
+        "adding new term" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "foo": {"@context": {"bar": "http://example.org/bar"}}
+            },
+            "foo": {
+              "bar": "baz"
+            }
+          }),
+          output: %([
+            {
+              "http://example/foo": [{"http://example.org/bar": [{"@value": "baz"}]}]
+            }
+          ])
+        },
+        "overriding a term" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "foo": {"@context": {"bar": {"@type": "@id"}}},
+              "bar": {"@type": "http://www.w3.org/2001/XMLSchema#string"}
+            },
+            "foo": {
+              "bar": "http://example/baz"
+            }
+          }),
+          output: %([
+            {
+              "http://example/foo": [{"http://example/bar": [{"@id": "http://example/baz"}]}]
+            }
+          ])
+        },
+        "property and value with different terms mapping to the same expanded property" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "foo": {"@context": {"Bar": {"@id": "bar"}}}
+            },
+            "foo": {
+              "Bar": "baz"
+            }
+          }),
+          output: %([
+            {
+              "http://example/foo": [{
+                "http://example/bar": [
+                  {"@value": "baz"}
+                ]}
+              ]
+            }
+          ])
+        },
+        "deep @context affects nested nodes" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "foo": {"@context": {"baz": {"@type": "@vocab"}}}
+            },
+            "foo": {
+              "bar": {
+                "baz": "buzz"
+              }
+            }
+          }),
+          output: %([
+            {
+              "http://example/foo": [{
+                "http://example/bar": [{
+                  "http://example/baz": [{"@id": "http://example/buzz"}]
+                }]
+              }]
+            }
+          ])
+        },
+        "scoped context layers on intemediate contexts" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "b": {"@context": {"c": "http://example.org/c"}}
+            },
+            "a": {
+              "@context": {"@vocab": "http://example.com/"},
+              "b": {
+                "a": "A in example.com",
+                "c": "C in example.org"
+              },
+              "c": "C in example.com"
+            },
+            "c": "C in example"
+          }),
+          output: %([{
+            "http://example/a": [{
+              "http://example.com/c": [{"@value": "C in example.com"}],
+              "http://example/b": [{
+                "http://example.com/a": [{"@value": "A in example.com"}],
+                "http://example.org/c": [{"@value": "C in example.org"}]
+              }]
+            }],
+            "http://example/c": [{"@value": "C in example"}]
+          }])
+        },
+        "Raises InvalidTermDefinition if processingMode is not specified" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "foo": {"@context": {"bar": "http://example.org/bar"}}
+            },
+            "foo": {
+              "bar": "baz"
+            }
+          }),
+          processingMode: nil,
+          exception: JSON::LD::JsonLdError::InvalidTermDefinition
+        },
+      }.each do |title, params|
+        it(title) {run_expand({processingMode: "json-ld-1.1"}.merge(params))}
+      end
+    end
+
+    context "scoped context on @type" do
+      {
+        "adding new term" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "Foo": {"@context": {"bar": "http://example.org/bar"}}
+            },
+            "a": {"@type": "Foo", "bar": "baz"}
+          }),
+          output: %([
+            {
+              "http://example/a": [{
+                "@type": ["http://example/Foo"],
+                "http://example.org/bar": [{"@value": "baz"}]
+              }]
+            }
+          ])
+        },
+        "overriding a term" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "Foo": {"@context": {"bar": {"@type": "@id"}}},
+              "bar": {"@type": "http://www.w3.org/2001/XMLSchema#string"}
+            },
+            "a": {"@type": "Foo", "bar": "http://example/baz"}
+          }),
+          output: %([
+            {
+              "http://example/a": [{
+                "@type": ["http://example/Foo"],
+                "http://example/bar": [{"@id": "http://example/baz"}]
+              }]
+            }
+          ])
+        },
+        "alias of @type" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "type": "@type",
+              "Foo": {"@context": {"bar": "http://example.org/bar"}}
+            },
+            "a": {"type": "Foo", "bar": "baz"}
+          }),
+          output: %([
+            {
+              "http://example/a": [{
+                "@type": ["http://example/Foo"],
+                "http://example.org/bar": [{"@value": "baz"}]
+              }]
+            }
+          ])
+        },
+        "deep @context affects nested nodes" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "Foo": {"@context": {"baz": {"@type": "@vocab"}}}
+            },
+            "@type": "Foo",
+            "bar": {"baz": "buzz"}
+          }),
+          output: %([
+            {
+              "@type": ["http://example/Foo"],
+              "http://example/bar": [{
+                "http://example/baz": [{"@id": "http://example/buzz"}]
+              }]
+            }
+          ])
+        },
+        "scoped context layers on intemediate contexts" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "B": {"@context": {"c": "http://example.org/c"}}
+            },
+            "a": {
+              "@context": {"@vocab": "http://example.com/"},
+              "@type": "B",
+              "a": "A in example.com",
+              "c": "C in example.org"
+            },
+            "c": "C in example"
+          }),
+          output: %([{
+            "http://example/a": [{
+              "@type": ["http://example/B"],
+              "http://example.com/a": [{"@value": "A in example.com"}],
+              "http://example.org/c": [{"@value": "C in example.org"}]
+            }],
+            "http://example/c": [{"@value": "C in example"}]
+          }])
+        },
+        "with @container: @type" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "typemap": {"@container": "@type"},
+              "Type": {"@context": {"a": "http://example.org/a"}}
+            },
+            "typemap": {
+              "Type": {"a": "Object with @type <Type>"}
+            }
+          }),
+          output: %([{
+            "http://example/typemap": [
+              {"http://example.org/a": [{"@value": "Object with @type <Type>"}], "@type": ["http://example/Type"]}
+            ]
+          }])
+        },
+        "Raises InvalidTermDefinition if processingMode is not specified" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "Foo": {"@context": {"bar": "http://example.org/bar"}}
+            },
+            "a": {"@type": "Foo", "bar": "baz"}
+          }),
+          processingMode: nil,
+          exception: JSON::LD::JsonLdError::InvalidTermDefinition
+        },
+      }.each do |title, params|
+        it(title) {run_expand({processingMode: "json-ld-1.1"}.merge(params))}
       end
     end
 
     context "@reverse" do
       {
+        "@container: @reverse" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "rev": { "@reverse": "forward", "@type": "@id"}
+            },
+            "@id": "http://example/one",
+            "rev": "http://example/two"
+          }),
+          output: %([{
+            "@id": "http://example/one",
+            "@reverse": {
+              "http://example/forward": [
+                {
+                  "@id": "http://example/two"
+                }
+              ]
+            }
+          }])
+        },
         "expand-0037" => {
-          input: ::JSON.parse(%({
+          input: %({
             "@context": {
               "name": "http://xmlns.com/foaf/0.1/name"
             },
@@ -691,8 +1494,8 @@ describe JSON::LD::API do
                 "name": "Dave Longley"
               }
             }
-          })),
-          output: ::JSON.parse(%([
+          }),
+          output: %([
             {
               "@id": "http://example.com/people/markus",
               "@reverse": {
@@ -713,10 +1516,10 @@ describe JSON::LD::API do
                 }
               ]
             }
-          ]))
+          ])
         },
         "expand-0043" => {
-          input: ::JSON.parse(%({
+          input: %({
             "@context": {
               "name": "http://xmlns.com/foaf/0.1/name",
               "isKnownBy": { "@reverse": "http://xmlns.com/foaf/0.1/knows" }
@@ -735,8 +1538,8 @@ describe JSON::LD::API do
                 }
               ]
             }
-          })),
-          output: ::JSON.parse(%([
+          }),
+          output: %([
             {
               "@id": "http://example.com/people/markus",
               "http://xmlns.com/foaf/0.1/knows": [
@@ -763,48 +1566,19 @@ describe JSON::LD::API do
                 }
               ]
             }
-          ]))
+          ])
         },
-      }.each do |title, params|
-        it title do
-          jld = JSON::LD::API.expand(params[:input], logger: logger)
-          expect(jld).to produce(params[:output], logger)
-        end
-      end
-    end
-
-    context "@index" do
-      {
-        "string annotation" => {
-          input: {
-            "@context" => {
-              "container" => {
-                "@id" => "http://example.com/container",
-                "@container" => "@index"
-              }
-            },
-            "@id" => "http://example.com/annotationsTest",
-            "container" => {
-              "en" => "The Queen",
-              "de" => [ "Die Königin", "Ihre Majestät" ]
-            }
-          },
-          output: [
-            {
-              "@id" => "http://example.com/annotationsTest",
-              "http://example.com/container" => [
-                {"@value" => "Die Königin", "@index" => "de"},
-                {"@value" => "Ihre Majestät", "@index" => "de"},
-                {"@value" => "The Queen", "@index" => "en"}
-              ]
+        "@reverse object with an @id property" => {
+          input: %({
+            "@id": "http://example/foo",
+            "@reverse": {
+              "@id": "http://example/bar"
             }
-          ]
+          }),
+          exception: JSON::LD::JsonLdError::InvalidReversePropertyMap,
         },
       }.each do |title, params|
-        it title do
-          jld = JSON::LD::API.expand(params[:input], logger: logger)
-          expect(jld).to produce(params[:output], logger)
-        end
+        it(title) {run_expand params}
       end
     end
 
@@ -825,52 +1599,33 @@ describe JSON::LD::API do
           },
           exception: JSON::LD::JsonLdError::InvalidLanguageTaggedString
         },
-        "@list containing @list" => {
-          input: {
-            "http://example.com/foo" => {"@list" => [{"@list" => ["baz"]}]}
-          },
-          exception: JSON::LD::JsonLdError::ListOfLists
-        },
-        "@list containing @list (with coercion)" => {
-          input: {
-            "@context" => {"foo" => {"@id" => "http://example.com/foo", "@container" => "@list"}},
-            "foo" => [{"@list" => ["baz"]}]
-          },
-          exception: JSON::LD::JsonLdError::ListOfLists
-        },
-        "coerced @list containing an array" => {
-          input: {
-            "@context" => {"foo" => {"@id" => "http://example.com/foo", "@container" => "@list"}},
-            "foo" => [["baz"]]
-          },
-          exception: JSON::LD::JsonLdError::ListOfLists
-        },
-        "@reverse object with an @id property" => {
-          input: JSON.parse(%({
-            "@id": "http://example/foo",
-            "@reverse": {
-              "@id": "http://example/bar"
-            }
-          })),
-          exception: JSON::LD::JsonLdError::InvalidReversePropertyMap,
-        },
         "colliding keywords" => {
-          input: JSON.parse(%({
+          input: %({
             "@context": {
               "id": "@id",
               "ID": "@id"
             },
             "id": "http://example/foo",
             "ID": "http://example/bar"
-          })),
+          }),
           exception: JSON::LD::JsonLdError::CollidingKeywords,
         }
       }.each do |title, params|
-        it title do
-          #JSON::LD::API.expand(params[:input], logger: logger).should produce([], logger)
-          expect {JSON::LD::API.expand(params[:input])}.to raise_error(params[:exception])
-        end
+        it(title) {run_expand params}
       end
     end
   end
+
+  def run_expand(params)
+    input, output, processingMode = params[:input], params[:output], params[:processingMode]
+    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)}.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)
+    end
+  end
 end