diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
new file mode 100644
index 0000000..2a038dd
--- /dev/null
+++ b/.github/workflows/ci.yaml
@@ -0,0 +1,19 @@
+name: CI
+on: push
+jobs:
+  test:
+    runs-on: ubuntu-20.04
+    strategy:
+      matrix:
+        node:
+          - '12'
+          - '14'
+          - '16'
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node }}
+      - run: npm install
+      - run: npm test
+      - run: npm run coverage
diff --git a/.gitignore b/.gitignore
index 2077e44..4811400 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,3 @@
-.idea
 coverage
 node_modules
+package-lock.json
diff --git a/.npmrc b/.npmrc
deleted file mode 100644
index 43c97e7..0000000
--- a/.npmrc
+++ /dev/null
@@ -1 +0,0 @@
-package-lock=false
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index ceafed9..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-language: node_js
-node_js:
-  - "6"
-  - "8"
-  - "10"
diff --git a/dist/rdf-data-model.js b/dist/rdf-data-model.js
index 8f45588..2f9cd25 100644
--- a/dist/rdf-data-model.js
+++ b/dist/rdf-data-model.js
@@ -1,165 +1,201 @@
-(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.rdf = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
-var DataFactory = require('./lib/data-factory')
-
-module.exports = DataFactory
-
-},{"./lib/data-factory":3}],2:[function(require,module,exports){
-function BlankNode (id) {
-  this.value = id || ('b' + (++BlankNode.nextId))
-}
-
-BlankNode.prototype.equals = function (other) {
-  return !!other && other.termType === this.termType && other.value === this.value
-}
-
-BlankNode.prototype.termType = 'BlankNode'
-
-BlankNode.nextId = 0
-
-module.exports = BlankNode
-
-},{}],3:[function(require,module,exports){
-var BlankNode = require('./blank-node')
-var DefaultGraph = require('./default-graph')
-var Literal = require('./literal')
-var NamedNode = require('./named-node')
-var Quad = require('./quad')
-var Variable = require('./variable')
-
-function DataFactory () {}
-
-DataFactory.namedNode = function (value) {
-  return new NamedNode(value)
-}
-
-DataFactory.blankNode = function (value) {
-  return new BlankNode(value)
-}
-
-DataFactory.literal = function (value, languageOrDatatype) {
-  if (typeof languageOrDatatype === 'string') {
-    if (languageOrDatatype.indexOf(':') === -1) {
-      return new Literal(value, languageOrDatatype)
-    }
-
-    return new Literal(value, null, DataFactory.namedNode(languageOrDatatype))
-  }
-
-  return new Literal(value, null, languageOrDatatype)
-}
-
-DataFactory.defaultGraph = function () {
-  return DataFactory.defaultGraphInstance
-}
-
-DataFactory.variable = function (value) {
-  return new Variable(value)
-}
-
-DataFactory.triple = function (subject, predicate, object) {
-  return DataFactory.quad(subject, predicate, object)
-}
-
-DataFactory.quad = function (subject, predicate, object, graph) {
-  return new Quad(subject, predicate, object, graph || DataFactory.defaultGraphInstance)
-}
-
-DataFactory.defaultGraphInstance = new DefaultGraph()
-
-module.exports = DataFactory
-
-},{"./blank-node":2,"./default-graph":4,"./literal":5,"./named-node":6,"./quad":7,"./variable":8}],4:[function(require,module,exports){
-function DefaultGraph () {
-  this.value = ''
-}
-
-DefaultGraph.prototype.equals = function (other) {
-  return !!other && other.termType === this.termType
-}
-
-DefaultGraph.prototype.termType = 'DefaultGraph'
-
-module.exports = DefaultGraph
-
-},{}],5:[function(require,module,exports){
-var NamedNode = require('./named-node')
-
-function Literal (value, language, datatype) {
-  this.value = value
-  this.datatype = Literal.stringDatatype
-  this.language = ''
-
-  if (language) {
-    this.language = language
-    this.datatype = Literal.langStringDatatype
-  } else if (datatype) {
-    this.datatype = datatype
-  }
-}
-
-Literal.prototype.equals = function (other) {
-  return !!other && other.termType === this.termType && other.value === this.value &&
-    other.language === this.language && other.datatype.equals(this.datatype)
-}
-
-Literal.prototype.termType = 'Literal'
-Literal.langStringDatatype = new NamedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString')
-Literal.stringDatatype = new NamedNode('http://www.w3.org/2001/XMLSchema#string')
-
-module.exports = Literal
-
-},{"./named-node":6}],6:[function(require,module,exports){
-function NamedNode (iri) {
-  this.value = iri
-}
-
-NamedNode.prototype.equals = function (other) {
-  return !!other && other.termType === this.termType && other.value === this.value
-}
-
-NamedNode.prototype.termType = 'NamedNode'
-
-module.exports = NamedNode
-
-},{}],7:[function(require,module,exports){
-var DefaultGraph = require('./default-graph')
-
-function Quad (subject, predicate, object, graph) {
-  this.subject = subject
-  this.predicate = predicate
-  this.object = object
-
-  if (graph) {
-    this.graph = graph
+(function (f) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') {
+    module.exports = f()
+  } else if (typeof define === 'function' && define.amd) {
+    define([], f)
   } else {
-    this.graph = new DefaultGraph()
+    let g; if (typeof window !== 'undefined') {
+      g = window
+    } else if (typeof global !== 'undefined') {
+      g = global
+    } else if (typeof self !== 'undefined') {
+      g = self
+    } else {
+      g = this
+    }g.rdf = f()
   }
-}
-
-Quad.prototype.equals = function (other) {
-  // `|| !other.termType` is for backwards-compatibility with old factories without RDF* support.
-  return !!other && (other.termType === 'Quad' || !other.termType) &&
+})(function () {
+  let define, module, exports; return (function () {
+    function r (e, n, t) {
+      function o (i, f) {
+        if (!n[i]) {
+          if (!e[i]) {
+            const c = typeof require === 'function' && require; if (!f && c) {
+              return c(i, !0)
+            } if (u) {
+              return u(i, !0)
+            } const a = new Error("Cannot find module '" + i + "'"); throw a.code = 'MODULE_NOT_FOUND', a
+          } const p = n[i] = { exports: {} }; e[i][0].call(p.exports, function (r) {
+            const n = e[i][1][r]; return o(n || r)
+          }, p, p.exports, r, e, n, t)
+        } return n[i].exports
+      } for (var u = typeof require === 'function' && require, i = 0; i < t.length; i++) {
+        o(t[i])
+      } return o
+    } return r
+  })()({
+    1: [function (require, module, exports) {
+      const DataFactory = require('./lib/data-factory')
+
+      module.exports = DataFactory
+    }, { './lib/data-factory': 3 }],
+    2: [function (require, module, exports) {
+      function BlankNode (id) {
+        this.value = id || ('b' + (++BlankNode.nextId))
+      }
+
+      BlankNode.prototype.equals = function (other) {
+        return !!other && other.termType === this.termType && other.value === this.value
+      }
+
+      BlankNode.prototype.termType = 'BlankNode'
+
+      BlankNode.nextId = 0
+
+      module.exports = BlankNode
+    }, {}],
+    3: [function (require, module, exports) {
+      const BlankNode = require('./blank-node')
+      const DefaultGraph = require('./default-graph')
+      const Literal = require('./literal')
+      const NamedNode = require('./named-node')
+      const Quad = require('./quad')
+      const Variable = require('./variable')
+
+      function DataFactory () {}
+
+      DataFactory.namedNode = function (value) {
+        return new NamedNode(value)
+      }
+
+      DataFactory.blankNode = function (value) {
+        return new BlankNode(value)
+      }
+
+      DataFactory.literal = function (value, languageOrDatatype) {
+        if (typeof languageOrDatatype === 'string') {
+          if (languageOrDatatype.indexOf(':') === -1) {
+            return new Literal(value, languageOrDatatype)
+          }
+
+          return new Literal(value, null, DataFactory.namedNode(languageOrDatatype))
+        }
+
+        return new Literal(value, null, languageOrDatatype)
+      }
+
+      DataFactory.defaultGraph = function () {
+        return DataFactory.defaultGraphInstance
+      }
+
+      DataFactory.variable = function (value) {
+        return new Variable(value)
+      }
+
+      DataFactory.triple = function (subject, predicate, object) {
+        return DataFactory.quad(subject, predicate, object)
+      }
+
+      DataFactory.quad = function (subject, predicate, object, graph) {
+        return new Quad(subject, predicate, object, graph || DataFactory.defaultGraphInstance)
+      }
+
+      DataFactory.defaultGraphInstance = new DefaultGraph()
+
+      module.exports = DataFactory
+    }, { './blank-node': 2, './default-graph': 4, './literal': 5, './named-node': 6, './quad': 7, './variable': 8 }],
+    4: [function (require, module, exports) {
+      function DefaultGraph () {
+        this.value = ''
+      }
+
+      DefaultGraph.prototype.equals = function (other) {
+        return !!other && other.termType === this.termType
+      }
+
+      DefaultGraph.prototype.termType = 'DefaultGraph'
+
+      module.exports = DefaultGraph
+    }, {}],
+    5: [function (require, module, exports) {
+      const NamedNode = require('./named-node')
+
+      function Literal (value, language, datatype) {
+        this.value = value
+        this.datatype = Literal.stringDatatype
+        this.language = ''
+
+        if (language) {
+          this.language = language
+          this.datatype = Literal.langStringDatatype
+        } else if (datatype) {
+          this.datatype = datatype
+        }
+      }
+
+      Literal.prototype.equals = function (other) {
+        return !!other && other.termType === this.termType && other.value === this.value &&
+    other.language === this.language && other.datatype.equals(this.datatype)
+      }
+
+      Literal.prototype.termType = 'Literal'
+      Literal.langStringDatatype = new NamedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString')
+      Literal.stringDatatype = new NamedNode('http://www.w3.org/2001/XMLSchema#string')
+
+      module.exports = Literal
+    }, { './named-node': 6 }],
+    6: [function (require, module, exports) {
+      function NamedNode (iri) {
+        this.value = iri
+      }
+
+      NamedNode.prototype.equals = function (other) {
+        return !!other && other.termType === this.termType && other.value === this.value
+      }
+
+      NamedNode.prototype.termType = 'NamedNode'
+
+      module.exports = NamedNode
+    }, {}],
+    7: [function (require, module, exports) {
+      const DefaultGraph = require('./default-graph')
+
+      function Quad (subject, predicate, object, graph) {
+        this.subject = subject
+        this.predicate = predicate
+        this.object = object
+
+        if (graph) {
+          this.graph = graph
+        } else {
+          this.graph = new DefaultGraph()
+        }
+      }
+
+      Quad.prototype.equals = function (other) {
+        // `|| !other.termType` is for backwards-compatibility with old factories without RDF* support.
+        return !!other && (other.termType === 'Quad' || !other.termType) &&
     other.subject.equals(this.subject) && other.predicate.equals(this.predicate) &&
     other.object.equals(this.object) && other.graph.equals(this.graph)
-}
-
-Quad.prototype.termType = 'Quad'
-Quad.prototype.value = ''
-
-module.exports = Quad
+      }
 
-},{"./default-graph":4}],8:[function(require,module,exports){
-function Variable (name) {
-  this.value = name
-}
+      Quad.prototype.termType = 'Quad'
+      Quad.prototype.value = ''
 
-Variable.prototype.equals = function (other) {
-  return !!other && other.termType === this.termType && other.value === this.value
-}
+      module.exports = Quad
+    }, { './default-graph': 4 }],
+    8: [function (require, module, exports) {
+      function Variable (name) {
+        this.value = name
+      }
 
-Variable.prototype.termType = 'Variable'
+      Variable.prototype.equals = function (other) {
+        return !!other && other.termType === this.termType && other.value === this.value
+      }
 
-module.exports = Variable
+      Variable.prototype.termType = 'Variable'
 
-},{}]},{},[1])(1)
-});
+      module.exports = Variable
+    }, {}]
+  }, {}, [1])(1)
+})
diff --git a/index.js b/index.js
index f5127cb..c069a4e 100644
--- a/index.js
+++ b/index.js
@@ -1,3 +1,3 @@
-var DataFactory = require('./lib/data-factory')
+const DataFactory = require('./lib/data-factory')
 
 module.exports = DataFactory
diff --git a/lib/data-factory.js b/lib/data-factory.js
index d1e7fb3..6ffcc8c 100644
--- a/lib/data-factory.js
+++ b/lib/data-factory.js
@@ -1,9 +1,9 @@
-var BlankNode = require('./blank-node')
-var DefaultGraph = require('./default-graph')
-var Literal = require('./literal')
-var NamedNode = require('./named-node')
-var Quad = require('./quad')
-var Variable = require('./variable')
+const BlankNode = require('./blank-node')
+const DefaultGraph = require('./default-graph')
+const Literal = require('./literal')
+const NamedNode = require('./named-node')
+const Quad = require('./quad')
+const Variable = require('./variable')
 
 function DataFactory () {}
 
diff --git a/lib/literal.js b/lib/literal.js
index 74988fb..b5405e7 100644
--- a/lib/literal.js
+++ b/lib/literal.js
@@ -1,4 +1,4 @@
-var NamedNode = require('./named-node')
+const NamedNode = require('./named-node')
 
 function Literal (value, language, datatype) {
   this.value = value
diff --git a/lib/quad.js b/lib/quad.js
index dbfae68..f1b8fce 100644
--- a/lib/quad.js
+++ b/lib/quad.js
@@ -1,4 +1,4 @@
-var DefaultGraph = require('./default-graph')
+const DefaultGraph = require('./default-graph')
 
 function Quad (subject, predicate, object, graph) {
   this.subject = subject
diff --git a/package.json b/package.json
index be36924..a132f39 100644
--- a/package.json
+++ b/package.json
@@ -4,10 +4,9 @@
   "description": "A basic implementation of the RDFJS Data Model",
   "main": "index.js",
   "scripts": {
-    "build-dist": "browserify index.js --standalone rdf --outfile dist/rdf-data-model.js",
-    "lint": "standard *.js bin/*.js lib/*.js test/*.js",
-    "prepublish": "npm run build-dist",
-    "test": "npm run lint && mocha"
+    "coverage": "codecov",
+    "prepublish": "browserify index.js --standalone rdf --outfile dist/rdf-data-model.js",
+    "test": "stricter-standard *.js bin/*.js lib/*.js test/*.js && c8 --reporter=lcov --reporter=text mocha"
   },
   "bin": {
     "rdfjs-data-model-test": "./bin/test.js"
@@ -32,11 +31,10 @@
     "@types/rdf-js": "*"
   },
   "devDependencies": {
-    "browserify": "^16.2.2",
-    "mocha": "^5.2.0",
-    "standard": "^11.0.1"
-  },
-  "engines": {
-    "node": ">=6"
+    "browserify": "^17.0.0",
+    "c8": "^7.7.3",
+    "codecov": "^3.8.2",
+    "mocha": "^9.0.1",
+    "stricter-standard": "^0.2.0"
   }
 }
diff --git a/test/blank-node.js b/test/blank-node.js
index 807578b..7d7b082 100644
--- a/test/blank-node.js
+++ b/test/blank-node.js
@@ -1,71 +1,68 @@
-'use strict'
-
-/* global describe, it */
-
-var assert = require('assert')
+const { strictEqual, notStrictEqual } = require('assert')
+const { describe, it } = require('mocha')
 
 function runTests (DataFactory) {
   describe('.blankNode', function () {
     it('should be a static method', function () {
-      assert.equal(typeof DataFactory.blankNode, 'function')
+      strictEqual(typeof DataFactory.blankNode, 'function')
     })
 
     it('should create an object with a termType property that contains the value "BlankNode"', function () {
-      var term = DataFactory.blankNode()
+      const term = DataFactory.blankNode()
 
-      assert.equal(term.termType, 'BlankNode')
+      strictEqual(term.termType, 'BlankNode')
     })
 
     it('should create an object with a value property that contains a unique identifier', function () {
-      var term1 = DataFactory.blankNode()
-      var term2 = DataFactory.blankNode()
+      const term1 = DataFactory.blankNode()
+      const term2 = DataFactory.blankNode()
 
-      assert.notEqual(term1.value, term2.value)
+      notStrictEqual(term1.value, term2.value)
     })
 
     it('should create an object with a value property that contains the given identifier', function () {
-      var id = 'b1'
-      var term = DataFactory.blankNode(id)
+      const id = 'b1'
+      const term = DataFactory.blankNode(id)
 
-      assert.equal(term.value, id)
+      strictEqual(term.value, id)
     })
 
     describe('.equals', function () {
       it('should be a method', function () {
-        var term = DataFactory.blankNode()
+        const term = DataFactory.blankNode()
 
-        assert.equal(typeof term.equals, 'function')
+        strictEqual(typeof term.equals, 'function')
       })
 
       it('should return true if termType and value are equal', function () {
-        var id = 'b1'
-        var term = DataFactory.blankNode(id)
-        var mock = {termType: 'BlankNode', value: id}
+        const id = 'b1'
+        const term = DataFactory.blankNode(id)
+        const mock = { termType: 'BlankNode', value: id }
 
-        assert.equal(term.equals(mock), true)
+        strictEqual(term.equals(mock), true)
       })
 
       it('should return false if termType is not equal', function () {
-        var id = 'b1'
-        var term = DataFactory.blankNode(id)
-        var mock = {termType: 'NamedNode', value: id}
+        const id = 'b1'
+        const term = DataFactory.blankNode(id)
+        const mock = { termType: 'NamedNode', value: id }
 
-        assert.equal(term.equals(mock), false)
+        strictEqual(term.equals(mock), false)
       })
 
       it('should return false if value is not equal', function () {
-        var id = 'b1'
-        var term = DataFactory.blankNode(id)
-        var mock = {termType: 'BlankNode', value: id + '1'}
+        const id = 'b1'
+        const term = DataFactory.blankNode(id)
+        const mock = { termType: 'BlankNode', value: id + '1' }
 
-        assert.equal(term.equals(mock), false)
+        strictEqual(term.equals(mock), false)
       })
 
       it('should return false if value is falsy', function () {
-        var id = 'b1'
-        var term = DataFactory.blankNode(id)
+        const id = 'b1'
+        const term = DataFactory.blankNode(id)
 
-        assert.equal(term.equals(null), false)
+        strictEqual(term.equals(null), false)
       })
     })
   })
diff --git a/test/default-graph.js b/test/default-graph.js
index 586f3e0..f707de2 100644
--- a/test/default-graph.js
+++ b/test/default-graph.js
@@ -1,52 +1,49 @@
-'use strict'
-
-/* global describe, it */
-
-var assert = require('assert')
+const { strictEqual } = require('assert')
+const { describe, it } = require('mocha')
 
 function runTests (DataFactory) {
   describe('.defaultGraph', function () {
     it('should be a static method', function () {
-      assert.equal(typeof DataFactory.defaultGraph, 'function')
+      strictEqual(typeof DataFactory.defaultGraph, 'function')
     })
 
     it('should create an object with a termType property that contains the value "DefaultGraph"', function () {
-      var term = DataFactory.defaultGraph()
+      const term = DataFactory.defaultGraph()
 
-      assert.equal(term.termType, 'DefaultGraph')
+      strictEqual(term.termType, 'DefaultGraph')
     })
 
     it('should create an object with a value property that contains an empty string', function () {
-      var term = DataFactory.defaultGraph()
+      const term = DataFactory.defaultGraph()
 
-      assert.equal(term.value, '')
+      strictEqual(term.value, '')
     })
 
     describe('.equals', function () {
       it('should be a method', function () {
-        var term = DataFactory.defaultGraph()
+        const term = DataFactory.defaultGraph()
 
-        assert.equal(typeof term.equals, 'function')
+        strictEqual(typeof term.equals, 'function')
       })
 
       it('should return true if termType and value are equal', function () {
-        var term = DataFactory.defaultGraph()
-        var mock = {termType: 'DefaultGraph', value: ''}
+        const term = DataFactory.defaultGraph()
+        const mock = { termType: 'DefaultGraph', value: '' }
 
-        assert.equal(term.equals(mock), true)
+        strictEqual(term.equals(mock), true)
       })
 
       it('should return false if termType is not equal', function () {
-        var term = DataFactory.defaultGraph()
-        var mock = {termType: 'NamedNode', value: ''}
+        const term = DataFactory.defaultGraph()
+        const mock = { termType: 'NamedNode', value: '' }
 
-        assert.equal(term.equals(mock), false)
+        strictEqual(term.equals(mock), false)
       })
 
       it('should return false if value is falsy', function () {
-        var term = DataFactory.defaultGraph()
+        const term = DataFactory.defaultGraph()
 
-        assert.equal(term.equals(null), false)
+        strictEqual(term.equals(null), false)
       })
     })
   })
diff --git a/test/index.js b/test/index.js
index 89e83e1..4d0a9fd 100644
--- a/test/index.js
+++ b/test/index.js
@@ -1,5 +1,3 @@
-'use strict'
-
 function runTests (rdf) {
   require('./named-node')(rdf)
   require('./blank-node')(rdf)
diff --git a/test/literal.js b/test/literal.js
index 1f64cf6..ce566da 100644
--- a/test/literal.js
+++ b/test/literal.js
@@ -1,162 +1,159 @@
-'use strict'
-
-/* global describe, it */
-
-var assert = require('assert')
+const { strictEqual } = require('assert')
+const { describe, it } = require('mocha')
 
 function runTests (DataFactory) {
   describe('.literal', function () {
     it('should be a static method', function () {
-      assert.equal(typeof DataFactory.literal, 'function')
+      strictEqual(typeof DataFactory.literal, 'function')
     })
 
     it('should create an object with a termType property that contains the value "Literal"', function () {
-      var term = DataFactory.literal()
+      const term = DataFactory.literal()
 
-      assert.equal(term.termType, 'Literal')
+      strictEqual(term.termType, 'Literal')
     })
 
     it('should create an object with a value property that contains the given string', function () {
-      var string = 'example'
-      var term = DataFactory.literal(string)
+      const string = 'example'
+      const term = DataFactory.literal(string)
 
-      assert.equal(term.value, string)
+      strictEqual(term.value, string)
     })
 
     it('should create an object with a language property that contains an empty string', function () {
-      var string = 'example'
-      var term = DataFactory.literal(string)
+      const string = 'example'
+      const term = DataFactory.literal(string)
 
-      assert.equal(term.language, '')
+      strictEqual(term.language, '')
     })
 
     it('should create an object with a language property that contains the given language string', function () {
-      var string = 'example'
-      var language = 'en'
-      var term = DataFactory.literal(string, language)
+      const string = 'example'
+      const language = 'en'
+      const term = DataFactory.literal(string, language)
 
-      assert.equal(term.language, language)
+      strictEqual(term.language, language)
     })
 
     it('should create an object with a datatype property that contains a NamedNode with the value "http://www.w3.org/2001/XMLSchema#string"', function () {
-      var string = 'example'
-      var term = DataFactory.literal(string)
+      const string = 'example'
+      const term = DataFactory.literal(string)
 
-      assert.equal(term.datatype.termType, 'NamedNode')
-      assert.equal(term.datatype.value, 'http://www.w3.org/2001/XMLSchema#string')
+      strictEqual(term.datatype.termType, 'NamedNode')
+      strictEqual(term.datatype.value, 'http://www.w3.org/2001/XMLSchema#string')
     })
 
     it('should create an object with a datatype property that contains a NamedNode with the value "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"', function () {
-      var string = 'example'
-      var language = 'en'
-      var term = DataFactory.literal(string, language)
+      const string = 'example'
+      const language = 'en'
+      const term = DataFactory.literal(string, language)
 
-      assert.equal(term.datatype.termType, 'NamedNode')
-      assert.equal(term.datatype.value, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString')
+      strictEqual(term.datatype.termType, 'NamedNode')
+      strictEqual(term.datatype.value, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString')
     })
 
     it('should create an object with a datatype property that contains a NamedNode with the given IRI', function () {
-      var string = 'example'
-      var datatypeIRI = 'http://example.org'
-      var datatypeNode = DataFactory.namedNode(datatypeIRI)
-      var term = DataFactory.literal(string, datatypeNode)
+      const string = 'example'
+      const datatypeIRI = 'http://example.org'
+      const datatypeNode = DataFactory.namedNode(datatypeIRI)
+      const term = DataFactory.literal(string, datatypeNode)
 
-      assert.equal(term.datatype.termType, 'NamedNode')
-      assert.equal(term.datatype.value, datatypeIRI)
+      strictEqual(term.datatype.termType, 'NamedNode')
+      strictEqual(term.datatype.value, datatypeIRI)
     })
 
     it('should create an object with a datatype property that contains the given NamedNode', function () {
-      var string = 'example'
-      var datatype = {termType: 'NamedNode', value: 'http://example.org'}
-      var term = DataFactory.literal(string, datatype)
+      const string = 'example'
+      const datatype = { termType: 'NamedNode', value: 'http://example.org' }
+      const term = DataFactory.literal(string, datatype)
 
-      assert.equal(term.datatype.termType, 'NamedNode')
-      assert.equal(term.datatype.value, datatype.value)
+      strictEqual(term.datatype.termType, 'NamedNode')
+      strictEqual(term.datatype.value, datatype.value)
     })
 
     describe('.equals', function () {
       it('should be a method', function () {
-        var term = DataFactory.literal('')
+        const term = DataFactory.literal('')
 
-        assert.equal(typeof term.equals, 'function')
+        strictEqual(typeof term.equals, 'function')
       })
 
       it('should return true if termType, value, language and datatype are equal', function () {
-        var string = 'example'
-        var language = 'en'
-        var term = DataFactory.literal(string, language)
-        var mock = {
+        const string = 'example'
+        const language = 'en'
+        const term = DataFactory.literal(string, language)
+        const mock = {
           termType: 'Literal',
           value: string,
           language: language,
           datatype: DataFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString')
         }
 
-        assert.equal(term.equals(mock), true)
+        strictEqual(term.equals(mock), true)
       })
 
       it('should return false if termType is not equal', function () {
-        var string = 'example'
-        var language = 'en'
-        var term = DataFactory.literal(string, language)
-        var mock = {
+        const string = 'example'
+        const language = 'en'
+        const term = DataFactory.literal(string, language)
+        const mock = {
           termType: 'NamedNode',
           value: string,
           language: language,
           datatype: DataFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString')
         }
 
-        assert.equal(term.equals(mock), false)
+        strictEqual(term.equals(mock), false)
       })
 
       it('should return false if value is not equal', function () {
-        var string = 'example'
-        var language = 'en'
-        var term = DataFactory.literal(string, language)
-        var mock = {
+        const string = 'example'
+        const language = 'en'
+        const term = DataFactory.literal(string, language)
+        const mock = {
           termType: 'Literal',
           value: string + '1',
           language: language,
           datatype: DataFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString')
         }
 
-        assert.equal(term.equals(mock), false)
+        strictEqual(term.equals(mock), false)
       })
 
       it('should return false if language is not equal', function () {
-        var string = 'example'
-        var language = 'en'
-        var term = DataFactory.literal(string, language)
-        var mock = {
+        const string = 'example'
+        const language = 'en'
+        const term = DataFactory.literal(string, language)
+        const mock = {
           termType: 'Literal',
           value: string,
           language: 'de',
           datatype: DataFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString')
         }
 
-        assert.equal(term.equals(mock), false)
+        strictEqual(term.equals(mock), false)
       })
 
       it('should return false if datatype is not equal', function () {
-        var string = 'example'
-        var language = 'en'
-        var term = DataFactory.literal(string, language)
-        var mock = {
+        const string = 'example'
+        const language = 'en'
+        const term = DataFactory.literal(string, language)
+        const mock = {
           termType: 'Literal',
           value: string,
           language: language,
           datatype: DataFactory.namedNode('http://example.org')
         }
 
-        assert.equal(term.equals(mock), false)
+        strictEqual(term.equals(mock), false)
       })
 
       it('should return false if value is falsy', function () {
-        var string = 'example'
-        var language = 'en'
-        var term = DataFactory.literal(string, language)
+        const string = 'example'
+        const language = 'en'
+        const term = DataFactory.literal(string, language)
 
-        assert.equal(term.equals(null), false)
+        strictEqual(term.equals(null), false)
       })
     })
   })
diff --git a/test/named-node.js b/test/named-node.js
index 57a45e1..812b4cd 100644
--- a/test/named-node.js
+++ b/test/named-node.js
@@ -1,66 +1,63 @@
-'use strict'
-
-/* global describe, it */
-
-var assert = require('assert')
+const { strictEqual } = require('assert')
+const { describe, it } = require('mocha')
 
 function runTests (DataFactory) {
   describe('.namedNode', function () {
     it('should be a static method', function () {
-      assert.equal(typeof DataFactory.namedNode, 'function')
+      strictEqual(typeof DataFactory.namedNode, 'function')
     })
 
     it('should create an object with a termType property that contains the value "NamedNode"', function () {
-      var iri = 'http://example.org'
-      var term = DataFactory.namedNode(iri)
+      const iri = 'http://example.org'
+      const term = DataFactory.namedNode(iri)
 
-      assert.equal(term.termType, 'NamedNode')
+      strictEqual(term.termType, 'NamedNode')
     })
 
     it('should create an object with a value property that contains the given IRI', function () {
-      var iri = 'http://example.org'
-      var term = DataFactory.namedNode(iri)
+      const iri = 'http://example.org'
+      const term = DataFactory.namedNode(iri)
 
-      assert.equal(term.value, iri)
+      strictEqual(term.value, iri)
     })
 
     describe('.equals', function () {
       it('should be a method', function () {
-        var iri = 'http://example.org'
-        var term = DataFactory.namedNode(iri)
+        const iri = 'http://example.org'
+        const term = DataFactory.namedNode(iri)
 
-        assert.equal(typeof term.equals, 'function')
+        strictEqual(typeof term.equals, 'function')
       })
 
       it('should return true if termType and value are equal', function () {
-        var iri = 'http://example.org'
-        var term = DataFactory.namedNode(iri)
-        var mock = {termType: 'NamedNode', value: iri}
+        const iri = 'http://example.org'
+        const term = DataFactory.namedNode(iri)
+        const mock = { termType: 'NamedNode', value: iri }
 
-        assert.equal(term.equals(mock), true)
+        strictEqual(term.equals(mock), true)
       })
 
       it('should return false if termType is not equal', function () {
-        var iri = 'http://example.org'
-        var term = DataFactory.namedNode(iri)
-        var mock = {termType: 'BlankNode', value: iri}
+        const iri = 'http://example.org'
+        const term = DataFactory.namedNode(iri)
+        const mock = { termType: 'BlankNode', value: iri }
 
-        assert.equal(term.equals(mock), false)
+        strictEqual(term.equals(mock), false)
       })
 
       it('should return false if value is not equal', function () {
-        var iri = 'http://example.org'
-        var term = DataFactory.namedNode(iri)
-        var mock = {termType: 'NamedNode', value: iri + '1'}
+        const iri = 'http://example.org'
+        const term = DataFactory.namedNode(iri)
+        const mock = { termType: 'NamedNode', value: iri + '1' }
 
-        assert.equal(term.equals(mock), false)
+        strictEqual(term.equals(mock), false)
       })
 
       it('should return false if value is falsy', function () {
-        var iri = 'http://example.org'
-        var term = DataFactory.namedNode(iri)
+        const iri = 'http://example.org'
+        const term = DataFactory.namedNode(iri)
 
-        assert.equal(term.equals(null), false)
+        strictEqual(term.equals(null), false)
       })
     })
   })
diff --git a/test/quad.js b/test/quad.js
index f2bd25f..ed6747b 100644
--- a/test/quad.js
+++ b/test/quad.js
@@ -1,169 +1,166 @@
-'use strict'
-
-/* global describe, it */
-
-var assert = require('assert')
+const { strictEqual } = require('assert')
+const { describe, it } = require('mocha')
 
 function runTests (DataFactory) {
   describe('.quad', function () {
     it('should be a static method', function () {
-      assert.equal(typeof DataFactory.quad, 'function')
+      strictEqual(typeof DataFactory.quad, 'function')
     })
 
     it('should create an object with .subject, .predicate, .object and .graph with the given values', function () {
-      var subject = DataFactory.namedNode('http://example.org/subject')
-      var predicate = DataFactory.namedNode('http://example.org/predicate')
-      var object = DataFactory.namedNode('http://example.org/object')
-      var graph = DataFactory.namedNode('http://example.org/graph')
-      var quad = DataFactory.quad(subject, predicate, object, graph)
-
-      assert.equal(subject.equals(quad.subject), true)
-      assert.equal(predicate.equals(quad.predicate), true)
-      assert.equal(object.equals(quad.object), true)
-      assert.equal(graph.equals(quad.graph), true)
-
-      assert.equal(quad.termType, 'Quad')
-      assert.equal(quad.value, '')
+      const subject = DataFactory.namedNode('http://example.org/subject')
+      const predicate = DataFactory.namedNode('http://example.org/predicate')
+      const object = DataFactory.namedNode('http://example.org/object')
+      const graph = DataFactory.namedNode('http://example.org/graph')
+      const quad = DataFactory.quad(subject, predicate, object, graph)
+
+      strictEqual(subject.equals(quad.subject), true)
+      strictEqual(predicate.equals(quad.predicate), true)
+      strictEqual(object.equals(quad.object), true)
+      strictEqual(graph.equals(quad.graph), true)
+
+      strictEqual(quad.termType, 'Quad')
+      strictEqual(quad.value, '')
     })
 
     it('should create an object .graph set to DefaultGraph if the argument isn\'t given', function () {
-      var subject = DataFactory.namedNode('http://example.org/subject')
-      var predicate = DataFactory.namedNode('http://example.org/predicate')
-      var object = DataFactory.namedNode('http://example.org/object')
-      var graph = DataFactory.defaultGraph()
-      var quad = DataFactory.quad(subject, predicate, object)
+      const subject = DataFactory.namedNode('http://example.org/subject')
+      const predicate = DataFactory.namedNode('http://example.org/predicate')
+      const object = DataFactory.namedNode('http://example.org/object')
+      const graph = DataFactory.defaultGraph()
+      const quad = DataFactory.quad(subject, predicate, object)
 
-      assert.equal(quad.graph.equals(graph), true)
+      strictEqual(quad.graph.equals(graph), true)
 
-      assert.equal(quad.termType, 'Quad')
-      assert.equal(quad.value, '')
+      strictEqual(quad.termType, 'Quad')
+      strictEqual(quad.value, '')
     })
 
     describe('.equals', function () {
       it('should return true if the other quad contains the same subject, predicate, object and graph', function () {
-        var subject = DataFactory.namedNode('http://example.org/subject')
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object = DataFactory.namedNode('http://example.org/object')
-        var graph = DataFactory.namedNode('http://example.org/graph')
-        var quad1 = DataFactory.quad(subject, predicate, object, graph)
-        var quad2 = DataFactory.quad(subject, predicate, object, graph)
-
-        assert.equal(quad1.equals(quad2), true)
+        const subject = DataFactory.namedNode('http://example.org/subject')
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object = DataFactory.namedNode('http://example.org/object')
+        const graph = DataFactory.namedNode('http://example.org/graph')
+        const quad1 = DataFactory.quad(subject, predicate, object, graph)
+        const quad2 = DataFactory.quad(subject, predicate, object, graph)
+
+        strictEqual(quad1.equals(quad2), true)
       })
 
       it('should return true even if the other equal quad is from a non-RDF* factory', function () {
-        var subject = DataFactory.namedNode('http://example.org/subject')
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object = DataFactory.namedNode('http://example.org/object')
-        var graph = DataFactory.namedNode('http://example.org/graph')
-        var quad1 = DataFactory.quad(subject, predicate, object, graph)
-        var quad2 = { subject, predicate, object, graph }
-
-        assert.equal(quad1.equals(quad2), true)
+        const subject = DataFactory.namedNode('http://example.org/subject')
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object = DataFactory.namedNode('http://example.org/object')
+        const graph = DataFactory.namedNode('http://example.org/graph')
+        const quad1 = DataFactory.quad(subject, predicate, object, graph)
+        const quad2 = { subject, predicate, object, graph }
+
+        strictEqual(quad1.equals(quad2), true)
       })
 
       it('should return false if the subject of the other quad is not the same', function () {
-        var subject1 = DataFactory.namedNode('http://example.org/subject')
-        var subject2 = DataFactory.namedNode('http://example.com/subject')
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object = DataFactory.namedNode('http://example.org/object')
-        var graph = DataFactory.namedNode('http://example.org/graph')
-        var quad1 = DataFactory.quad(subject1, predicate, object, graph)
-        var quad2 = DataFactory.quad(subject2, predicate, object, graph)
-
-        assert.equal(quad1.equals(quad2), false)
+        const subject1 = DataFactory.namedNode('http://example.org/subject')
+        const subject2 = DataFactory.namedNode('http://example.com/subject')
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object = DataFactory.namedNode('http://example.org/object')
+        const graph = DataFactory.namedNode('http://example.org/graph')
+        const quad1 = DataFactory.quad(subject1, predicate, object, graph)
+        const quad2 = DataFactory.quad(subject2, predicate, object, graph)
+
+        strictEqual(quad1.equals(quad2), false)
       })
 
       it('should return false even if the other non-equal quad is from a non-RDF* factory', function () {
-        var subject1 = DataFactory.namedNode('http://example.org/subject')
-        var subject2 = DataFactory.namedNode('http://example.com/subject')
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object = DataFactory.namedNode('http://example.org/object')
-        var graph = DataFactory.namedNode('http://example.org/graph')
-        var quad1 = DataFactory.quad(subject1, predicate, object, graph)
-        var quad2 = { subject: subject2, predicate, object, graph }
-
-        assert.equal(quad1.equals(quad2), false)
+        const subject1 = DataFactory.namedNode('http://example.org/subject')
+        const subject2 = DataFactory.namedNode('http://example.com/subject')
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object = DataFactory.namedNode('http://example.org/object')
+        const graph = DataFactory.namedNode('http://example.org/graph')
+        const quad1 = DataFactory.quad(subject1, predicate, object, graph)
+        const quad2 = { subject: subject2, predicate, object, graph }
+
+        strictEqual(quad1.equals(quad2), false)
       })
 
       it('should return false if the predicate of the other quad is not the same', function () {
-        var subject = DataFactory.namedNode('http://example.org/subject')
-        var predicate1 = DataFactory.namedNode('http://example.org/predicate')
-        var predicate2 = DataFactory.namedNode('http://example.com/predicate')
-        var object = DataFactory.namedNode('http://example.org/object')
-        var graph = DataFactory.namedNode('http://example.org/graph')
-        var quad1 = DataFactory.quad(subject, predicate1, object, graph)
-        var quad2 = DataFactory.quad(subject, predicate2, object, graph)
-
-        assert.equal(quad1.equals(quad2), false)
+        const subject = DataFactory.namedNode('http://example.org/subject')
+        const predicate1 = DataFactory.namedNode('http://example.org/predicate')
+        const predicate2 = DataFactory.namedNode('http://example.com/predicate')
+        const object = DataFactory.namedNode('http://example.org/object')
+        const graph = DataFactory.namedNode('http://example.org/graph')
+        const quad1 = DataFactory.quad(subject, predicate1, object, graph)
+        const quad2 = DataFactory.quad(subject, predicate2, object, graph)
+
+        strictEqual(quad1.equals(quad2), false)
       })
 
       it('should return false if the object of the other quad is not the same', function () {
-        var subject = DataFactory.namedNode('http://example.org/subject')
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object1 = DataFactory.namedNode('http://example.org/object')
-        var object2 = DataFactory.namedNode('http://example.com/object')
-        var graph = DataFactory.namedNode('http://example.org/graph')
-        var quad1 = DataFactory.quad(subject, predicate, object1, graph)
-        var quad2 = DataFactory.quad(subject, predicate, object2, graph)
-
-        assert.equal(quad1.equals(quad2), false)
+        const subject = DataFactory.namedNode('http://example.org/subject')
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object1 = DataFactory.namedNode('http://example.org/object')
+        const object2 = DataFactory.namedNode('http://example.com/object')
+        const graph = DataFactory.namedNode('http://example.org/graph')
+        const quad1 = DataFactory.quad(subject, predicate, object1, graph)
+        const quad2 = DataFactory.quad(subject, predicate, object2, graph)
+
+        strictEqual(quad1.equals(quad2), false)
       })
 
       it('should return false if the graph of the other quad is not the same', function () {
-        var subject = DataFactory.namedNode('http://example.org/subject')
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object = DataFactory.namedNode('http://example.org/object')
-        var graph1 = DataFactory.namedNode('http://example.org/graph')
-        var graph2 = DataFactory.namedNode('http://example.com/graph')
-        var quad1 = DataFactory.quad(subject, predicate, object, graph1)
-        var quad2 = DataFactory.quad(subject, predicate, object, graph2)
-
-        assert.equal(quad1.equals(quad2), false)
+        const subject = DataFactory.namedNode('http://example.org/subject')
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object = DataFactory.namedNode('http://example.org/object')
+        const graph1 = DataFactory.namedNode('http://example.org/graph')
+        const graph2 = DataFactory.namedNode('http://example.com/graph')
+        const quad1 = DataFactory.quad(subject, predicate, object, graph1)
+        const quad2 = DataFactory.quad(subject, predicate, object, graph2)
+
+        strictEqual(quad1.equals(quad2), false)
       })
 
       it('should return false if value is falsy', function () {
-        var subject = DataFactory.namedNode('http://example.org/subject')
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object = DataFactory.namedNode('http://example.org/object')
-        var graph = DataFactory.namedNode('http://example.org/graph')
-        var quad = DataFactory.quad(subject, predicate, object, graph)
+        const subject = DataFactory.namedNode('http://example.org/subject')
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object = DataFactory.namedNode('http://example.org/object')
+        const graph = DataFactory.namedNode('http://example.org/graph')
+        const quad = DataFactory.quad(subject, predicate, object, graph)
 
-        assert.equal(quad.equals(null), false)
+        strictEqual(quad.equals(null), false)
       })
 
       it('should return false if value is another term', function () {
-        var subject = DataFactory.namedNode('http://example.org/subject')
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object = DataFactory.namedNode('http://example.org/object')
-        var graph = DataFactory.namedNode('http://example.org/graph')
-        var quad = DataFactory.quad(subject, predicate, object, graph)
-
-        assert.equal(quad.equals(DataFactory.namedNode('http://example.org/subject')), false)
-        assert.equal(quad.equals(DataFactory.literal('abc')), false)
-        assert.equal(quad.equals(DataFactory.variable('var')), false)
-        assert.equal(quad.equals(DataFactory.blankNode('bnode')), false)
-        assert.equal(quad.equals(DataFactory.defaultGraph()), false)
+        const subject = DataFactory.namedNode('http://example.org/subject')
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object = DataFactory.namedNode('http://example.org/object')
+        const graph = DataFactory.namedNode('http://example.org/graph')
+        const quad = DataFactory.quad(subject, predicate, object, graph)
+
+        strictEqual(quad.equals(DataFactory.namedNode('http://example.org/subject')), false)
+        strictEqual(quad.equals(DataFactory.literal('abc')), false)
+        strictEqual(quad.equals(DataFactory.variable('var')), false)
+        strictEqual(quad.equals(DataFactory.blankNode('bnode')), false)
+        strictEqual(quad.equals(DataFactory.defaultGraph()), false)
       })
 
       it('should return true for an equal nested quad', function () {
-        var subject = DataFactory.quad(
+        const subject = DataFactory.quad(
           DataFactory.namedNode('http://example.org/subjectInner1'),
           DataFactory.namedNode('http://example.org/predicateInner1'),
           DataFactory.namedNode('http://example.org/objectInner1')
         )
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object = DataFactory.quad(
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object = DataFactory.quad(
           DataFactory.namedNode('http://example.org/subjectInner2'),
           DataFactory.namedNode('http://example.org/predicateInner2'),
           DataFactory.namedNode('http://example.org/objectInner2'),
           DataFactory.namedNode('http://example.org/graphInner2')
         )
-        var graph = DataFactory.namedNode('http://example.org/graph')
-        var quad1 = DataFactory.quad(subject, predicate, object, graph)
-        var quad2 = DataFactory.quad(subject, predicate, object, graph)
+        const graph = DataFactory.namedNode('http://example.org/graph')
+        const quad1 = DataFactory.quad(subject, predicate, object, graph)
+        const quad2 = DataFactory.quad(subject, predicate, object, graph)
 
-        assert.equal(quad1.equals(quad2), true)
+        strictEqual(quad1.equals(quad2), true)
       })
     })
   })
diff --git a/test/test.js b/test/test.js
index d5222be..02c1342 100644
--- a/test/test.js
+++ b/test/test.js
@@ -1,3 +1,3 @@
-var rdf = require('..')
+const rdf = require('..')
 
 require('.')(rdf)
diff --git a/test/triple.js b/test/triple.js
index 2f63280..ba78635 100644
--- a/test/triple.js
+++ b/test/triple.js
@@ -1,99 +1,96 @@
-'use strict'
-
-/* global describe, it */
-
-var assert = require('assert')
+const { strictEqual } = require('assert')
+const { describe, it } = require('mocha')
 
 function runTests (DataFactory) {
   describe('.triple', function () {
     it('should be a static method', function () {
-      assert.equal(typeof DataFactory.triple, 'function')
+      strictEqual(typeof DataFactory.triple, 'function')
     })
 
     it('should create an object with .subject, .predicate and .object with the given values and .graph set to DefaultGraph', function () {
-      var subject = DataFactory.namedNode('http://example.org/subject')
-      var predicate = DataFactory.namedNode('http://example.org/predicate')
-      var object = DataFactory.namedNode('http://example.org/object')
-      var triple = DataFactory.triple(subject, predicate, object)
-
-      assert.equal(subject.equals(triple.subject), true)
-      assert.equal(predicate.equals(triple.predicate), true)
-      assert.equal(object.equals(triple.object), true)
-      assert.equal(DataFactory.defaultGraph().equals(triple.graph), true)
+      const subject = DataFactory.namedNode('http://example.org/subject')
+      const predicate = DataFactory.namedNode('http://example.org/predicate')
+      const object = DataFactory.namedNode('http://example.org/object')
+      const triple = DataFactory.triple(subject, predicate, object)
+
+      strictEqual(subject.equals(triple.subject), true)
+      strictEqual(predicate.equals(triple.predicate), true)
+      strictEqual(object.equals(triple.object), true)
+      strictEqual(DataFactory.defaultGraph().equals(triple.graph), true)
     })
 
     it('should ignore a 4th parameter and always use DefaultGraph', function () {
-      var subject = DataFactory.namedNode('http://example.org/subject')
-      var predicate = DataFactory.namedNode('http://example.org/predicate')
-      var object = DataFactory.namedNode('http://example.org/object')
-      var graph = DataFactory.namedNode('http://example.org/graph')
-      var triple = DataFactory.triple(subject, predicate, object, graph)
+      const subject = DataFactory.namedNode('http://example.org/subject')
+      const predicate = DataFactory.namedNode('http://example.org/predicate')
+      const object = DataFactory.namedNode('http://example.org/object')
+      const graph = DataFactory.namedNode('http://example.org/graph')
+      const triple = DataFactory.triple(subject, predicate, object, graph)
 
-      assert.equal(DataFactory.defaultGraph().equals(triple.graph), true)
+      strictEqual(DataFactory.defaultGraph().equals(triple.graph), true)
     })
 
     describe('.equals', function () {
       it('should return true if the other triple contains the same subject, predicate and object', function () {
-        var subject = DataFactory.namedNode('http://example.org/subject')
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object = DataFactory.namedNode('http://example.org/object')
-        var triple1 = DataFactory.triple(subject, predicate, object)
-        var triple2 = DataFactory.triple(subject, predicate, object)
+        const subject = DataFactory.namedNode('http://example.org/subject')
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object = DataFactory.namedNode('http://example.org/object')
+        const triple1 = DataFactory.triple(subject, predicate, object)
+        const triple2 = DataFactory.triple(subject, predicate, object)
 
-        assert.equal(triple1.equals(triple2), true)
+        strictEqual(triple1.equals(triple2), true)
       })
 
       it('should return false if the subject of the other triple is not the same', function () {
-        var subject1 = DataFactory.namedNode('http://example.org/subject')
-        var subject2 = DataFactory.namedNode('http://example.com/subject')
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object = DataFactory.namedNode('http://example.org/object')
-        var triple1 = DataFactory.triple(subject1, predicate, object)
-        var triple2 = DataFactory.triple(subject2, predicate, object)
-
-        assert.equal(triple1.equals(triple2), false)
+        const subject1 = DataFactory.namedNode('http://example.org/subject')
+        const subject2 = DataFactory.namedNode('http://example.com/subject')
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object = DataFactory.namedNode('http://example.org/object')
+        const triple1 = DataFactory.triple(subject1, predicate, object)
+        const triple2 = DataFactory.triple(subject2, predicate, object)
+
+        strictEqual(triple1.equals(triple2), false)
       })
 
       it('should return false if the predicate of the other triple is not the same', function () {
-        var subject = DataFactory.namedNode('http://example.org/subject')
-        var predicate1 = DataFactory.namedNode('http://example.org/predicate')
-        var predicate2 = DataFactory.namedNode('http://example.com/predicate')
-        var object = DataFactory.namedNode('http://example.org/object')
-        var triple1 = DataFactory.triple(subject, predicate1, object)
-        var triple2 = DataFactory.triple(subject, predicate2, object)
-
-        assert.equal(triple1.equals(triple2), false)
+        const subject = DataFactory.namedNode('http://example.org/subject')
+        const predicate1 = DataFactory.namedNode('http://example.org/predicate')
+        const predicate2 = DataFactory.namedNode('http://example.com/predicate')
+        const object = DataFactory.namedNode('http://example.org/object')
+        const triple1 = DataFactory.triple(subject, predicate1, object)
+        const triple2 = DataFactory.triple(subject, predicate2, object)
+
+        strictEqual(triple1.equals(triple2), false)
       })
 
       it('should return false if the object of the other triple is not the same', function () {
-        var subject = DataFactory.namedNode('http://example.org/subject')
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object1 = DataFactory.namedNode('http://example.org/object')
-        var object2 = DataFactory.namedNode('http://example.com/object')
-        var triple1 = DataFactory.triple(subject, predicate, object1)
-        var triple2 = DataFactory.triple(subject, predicate, object2)
-
-        assert.equal(triple1.equals(triple2), false)
+        const subject = DataFactory.namedNode('http://example.org/subject')
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object1 = DataFactory.namedNode('http://example.org/object')
+        const object2 = DataFactory.namedNode('http://example.com/object')
+        const triple1 = DataFactory.triple(subject, predicate, object1)
+        const triple2 = DataFactory.triple(subject, predicate, object2)
+
+        strictEqual(triple1.equals(triple2), false)
       })
 
       it('should return false if the graph of the other quad is not the same', function () {
-        var subject = DataFactory.namedNode('http://example.org/subject')
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object = DataFactory.namedNode('http://example.org/object')
-        var graph = DataFactory.namedNode('http://example.org/graph')
-        var triple = DataFactory.triple(subject, predicate, object)
-        var quad = DataFactory.quad(subject, predicate, object, graph)
-
-        assert.equal(triple.equals(quad), false)
+        const subject = DataFactory.namedNode('http://example.org/subject')
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object = DataFactory.namedNode('http://example.org/object')
+        const graph = DataFactory.namedNode('http://example.org/graph')
+        const triple = DataFactory.triple(subject, predicate, object)
+        const quad = DataFactory.quad(subject, predicate, object, graph)
+
+        strictEqual(triple.equals(quad), false)
       })
 
       it('should return false if value is falsy', function () {
-        var subject = DataFactory.namedNode('http://example.org/subject')
-        var predicate = DataFactory.namedNode('http://example.org/predicate')
-        var object = DataFactory.namedNode('http://example.org/object')
-        var triple = DataFactory.triple(subject, predicate, object)
+        const subject = DataFactory.namedNode('http://example.org/subject')
+        const predicate = DataFactory.namedNode('http://example.org/predicate')
+        const object = DataFactory.namedNode('http://example.org/object')
+        const triple = DataFactory.triple(subject, predicate, object)
 
-        assert.equal(triple.equals(null), false)
+        strictEqual(triple.equals(null), false)
       })
     })
   })
diff --git a/test/variable.js b/test/variable.js
index dfcac3e..1266691 100644
--- a/test/variable.js
+++ b/test/variable.js
@@ -1,8 +1,5 @@
-'use strict'
-
-/* global describe, it */
-
-var assert = require('assert')
+const { strictEqual } = require('assert')
+const { describe, it } = require('mocha')
 
 function runTests (DataFactory) {
   // support for Variable is optional
@@ -12,59 +9,59 @@ function runTests (DataFactory) {
 
   describe('.variable', function () {
     it('should be a static method', function () {
-      assert.equal(typeof DataFactory.variable, 'function')
+      strictEqual(typeof DataFactory.variable, 'function')
     })
 
     it('should create an object with a termType property that contains the value "Variable"', function () {
-      var name = 'v'
-      var term = DataFactory.variable(name)
+      const name = 'v'
+      const term = DataFactory.variable(name)
 
-      assert.equal(term.termType, 'Variable')
+      strictEqual(term.termType, 'Variable')
     })
 
     it('should create an object with a value property that contains the given name', function () {
-      var name = 'v'
-      var term = DataFactory.variable(name)
+      const name = 'v'
+      const term = DataFactory.variable(name)
 
-      assert.equal(term.value, name)
+      strictEqual(term.value, name)
     })
 
     describe('.equals', function () {
       it('should be a method', function () {
-        var term = DataFactory.variable()
+        const term = DataFactory.variable()
 
-        assert.equal(typeof term.equals, 'function')
+        strictEqual(typeof term.equals, 'function')
       })
 
       it('should return true if termType and value are equal', function () {
-        var name = 'v'
-        var term = DataFactory.variable(name)
-        var mock = {termType: 'Variable', value: name}
+        const name = 'v'
+        const term = DataFactory.variable(name)
+        const mock = { termType: 'Variable', value: name }
 
-        assert.equal(term.equals(mock), true)
+        strictEqual(term.equals(mock), true)
       })
 
       it('should return false if termType is not equal', function () {
-        var name = 'v'
-        var term = DataFactory.variable(name)
-        var mock = {termType: 'NamedNode', value: name}
+        const name = 'v'
+        const term = DataFactory.variable(name)
+        const mock = { termType: 'NamedNode', value: name }
 
-        assert.equal(term.equals(mock), false)
+        strictEqual(term.equals(mock), false)
       })
 
       it('should return false if value is not equal', function () {
-        var name = 'v'
-        var term = DataFactory.variable(name)
-        var mock = {termType: 'Variable', value: name + '1'}
+        const name = 'v'
+        const term = DataFactory.variable(name)
+        const mock = { termType: 'Variable', value: name + '1' }
 
-        assert.equal(term.equals(mock), false)
+        strictEqual(term.equals(mock), false)
       })
 
       it('should return false if value is falsy', function () {
-        var name = 'v'
-        var term = DataFactory.variable(name)
+        const name = 'v'
+        const term = DataFactory.variable(name)
 
-        assert.equal(term.equals(null), false)
+        strictEqual(term.equals(null), false)
       })
     })
   })