diff --git a/test/unit/tracks/audio-track-list.test.js b/test/unit/tracks/audio-track-list.test.js
index 7f730821b..6114a0951 100644
--- a/test/unit/tracks/audio-track-list.test.js
+++ b/test/unit/tracks/audio-track-list.test.js
@@ -1,97 +1,107 @@
+/* eslint-env qunit */
 import AudioTrackList from '../../../src/js/tracks/audio-track-list.js';
 import AudioTrack from '../../../src/js/tracks/audio-track.js';
 import EventTarget from '../../../src/js/event-target.js';
 
-q.module('Audio Track List');
+QUnit.module('Audio Track List');
+
+QUnit.test('trigger "change" when "enabledchange" is fired on a track', function() {
+  const track = new EventTarget();
 
-test('trigger "change" when "enabledchange" is fired on a track', function() {
-  let track = new EventTarget();
   track.loaded_ = true;
-  let audioTrackList = new AudioTrackList([track]);
+  const audioTrackList = new AudioTrackList([track]);
   let changes = 0;
-  let changeHandler = function() {
+  const changeHandler = function() {
     changes++;
   };
+
   audioTrackList.on('change', changeHandler);
   track.trigger('enabledchange');
-  equal(changes, 1, 'one change events for trigger');
+  QUnit.equal(changes, 1, 'one change events for trigger');
 
   audioTrackList.off('change', changeHandler);
   audioTrackList.onchange = changeHandler;
 
   track.trigger('enabledchange');
-  equal(changes, 2, 'one change events for another trigger');
+  QUnit.equal(changes, 2, 'one change events for another trigger');
 });
 
-test('only one track is ever enabled', function() {
-  let track = new AudioTrack({enabled: true});
-  let track2 = new AudioTrack({enabled: true});
-  let track3 = new AudioTrack({enabled: true});
-  let track4 = new AudioTrack();
-  let list = new AudioTrackList([track, track2]);
-  equal(track.enabled, false, 'track is disabled');
-  equal(track2.enabled, true, 'track2 is enabled');
+QUnit.test('only one track is ever enabled', function() {
+  const track = new AudioTrack({enabled: true});
+  const track2 = new AudioTrack({enabled: true});
+  const track3 = new AudioTrack({enabled: true});
+  const track4 = new AudioTrack();
+  const list = new AudioTrackList([track, track2]);
+
+  QUnit.equal(track.enabled, false, 'track is disabled');
+  QUnit.equal(track2.enabled, true, 'track2 is enabled');
 
   track.enabled = true;
-  equal(track.enabled, true, 'track is enabled');
-  equal(track2.enabled, false, 'track2 is disabled');
+  QUnit.equal(track.enabled, true, 'track is enabled');
+  QUnit.equal(track2.enabled, false, 'track2 is disabled');
 
   list.addTrack_(track3);
-  equal(track.enabled, false, 'track is disabled');
-  equal(track2.enabled, false, 'track2 is disabled');
-  equal(track3.enabled, true, 'track3 is enabled');
+  QUnit.equal(track.enabled, false, 'track is disabled');
+  QUnit.equal(track2.enabled, false, 'track2 is disabled');
+  QUnit.equal(track3.enabled, true, 'track3 is enabled');
 
   track.enabled = true;
-  equal(track.enabled, true, 'track is disabled');
-  equal(track2.enabled, false, 'track2 is disabled');
-  equal(track3.enabled, false, 'track3 is disabled');
+  QUnit.equal(track.enabled, true, 'track is disabled');
+  QUnit.equal(track2.enabled, false, 'track2 is disabled');
+  QUnit.equal(track3.enabled, false, 'track3 is disabled');
 
   list.addTrack_(track4);
-  equal(track.enabled, true, 'track is enabled');
-  equal(track2.enabled, false, 'track2 is disabled');
-  equal(track3.enabled, false, 'track3 is disabled');
-  equal(track4.enabled, false, 'track4 is disabled');
+  QUnit.equal(track.enabled, true, 'track is enabled');
+  QUnit.equal(track2.enabled, false, 'track2 is disabled');
+  QUnit.equal(track3.enabled, false, 'track3 is disabled');
+  QUnit.equal(track4.enabled, false, 'track4 is disabled');
 
 });
 
-test('all tracks can be disabled', function() {
-  let track = new AudioTrack();
-  let track2 = new AudioTrack();
-  let list = new AudioTrackList([track, track2]);
-  equal(track.enabled, false, 'track is disabled');
-  equal(track2.enabled, false, 'track2 is disabled');
+QUnit.test('all tracks can be disabled', function() {
+  const track = new AudioTrack();
+  const track2 = new AudioTrack();
+
+  /* eslint-disable no-unused-vars */
+  // we need audiotracklist here to verify that it does not
+  // re-enable a track
+  const list = new AudioTrackList([track, track2]);
+  /* eslint-enable no-unused-vars */
+
+  QUnit.equal(track.enabled, false, 'track is disabled');
+  QUnit.equal(track2.enabled, false, 'track2 is disabled');
 
   track.enabled = true;
-  equal(track.enabled, true, 'track is enabled');
-  equal(track2.enabled, false, 'track2 is disabled');
+  QUnit.equal(track.enabled, true, 'track is enabled');
+  QUnit.equal(track2.enabled, false, 'track2 is disabled');
 
   track.enabled = false;
-  equal(track.enabled, false, 'track is disabled');
-  equal(track2.enabled, false, 'track2 is disabled');
+  QUnit.equal(track.enabled, false, 'track is disabled');
+  QUnit.equal(track2.enabled, false, 'track2 is disabled');
 });
 
-test('trigger a change event per enabled change', function() {
-  let track = new AudioTrack({enabled: true});
-  let track2 = new AudioTrack({enabled: true});
-  let track3 = new AudioTrack({enabled: true});
-  let track4 = new AudioTrack();
-  let list = new AudioTrackList([track, track2]);
-
+QUnit.test('trigger a change event per enabled change', function() {
+  const track = new AudioTrack({enabled: true});
+  const track2 = new AudioTrack({enabled: true});
+  const track3 = new AudioTrack({enabled: true});
+  const track4 = new AudioTrack();
+  const list = new AudioTrackList([track, track2]);
   let change = 0;
+
   list.on('change', () => change++);
   track.enabled = true;
-  equal(change, 1, 'one change triggered');
+  QUnit.equal(change, 1, 'one change triggered');
 
   list.addTrack_(track3);
-  equal(change, 2, 'another change triggered by adding an enabled track');
+  QUnit.equal(change, 2, 'another change triggered by adding an enabled track');
 
   track.enabled = true;
-  equal(change, 3, 'another change trigger by changing enabled');
+  QUnit.equal(change, 3, 'another change trigger by changing enabled');
 
   track.enabled = false;
-  equal(change, 4, 'another change trigger by changing enabled');
+  QUnit.equal(change, 4, 'another change trigger by changing enabled');
 
   list.addTrack_(track4);
-  equal(change, 4, 'no change triggered by adding a disabled track');
+  QUnit.equal(change, 4, 'no change triggered by adding a disabled track');
 
 });
diff --git a/test/unit/tracks/audio-track.test.js b/test/unit/tracks/audio-track.test.js
index 4bc6ba99d..cac73568f 100644
--- a/test/unit/tracks/audio-track.test.js
+++ b/test/unit/tracks/audio-track.test.js
@@ -1,98 +1,102 @@
+/* eslint-env qunit */
 import AudioTrack from '../../../src/js/tracks/audio-track.js';
 import {AudioTrackKind} from '../../../src/js/tracks/track-enums.js';
 import TrackBaseline from './track-baseline';
 
-q.module('Audio Track');
+QUnit.module('Audio Track');
 
 // do baseline track testing
 TrackBaseline(AudioTrack, {
   id: '1',
   language: 'en',
   label: 'English',
-  kind: 'main',
+  kind: 'main'
 });
 
-test('can create an enabled propert on an AudioTrack', function() {
-  let enabled = true;
-  let track = new AudioTrack({
-    enabled,
+QUnit.test('can create an enabled propert on an AudioTrack', function() {
+  const enabled = true;
+  const track = new AudioTrack({
+    enabled
   });
-  equal(track.enabled, enabled, 'enabled value matches what we passed in');
+
+  QUnit.equal(track.enabled, enabled, 'enabled value matches what we passed in');
 });
 
-test('defaults when items not provided', function() {
-  let track = new AudioTrack();
+QUnit.test('defaults when items not provided', function() {
+  const track = new AudioTrack();
 
-  equal(track.kind, '', 'kind defaulted to empty string');
-  equal(track.enabled, false, 'enabled defaulted to true since there is one track');
-  equal(track.label, '', 'label defaults to empty string');
-  equal(track.language, '', 'language defaults to empty string');
-  ok(track.id.match(/vjs_track_\d{5}/), 'id defaults to vjs_track_GUID');
+  QUnit.equal(track.kind, '', 'kind defaulted to empty string');
+  QUnit.equal(track.enabled, false, 'enabled defaulted to true since there is one track');
+  QUnit.equal(track.label, '', 'label defaults to empty string');
+  QUnit.equal(track.language, '', 'language defaults to empty string');
+  QUnit.ok(track.id.match(/vjs_track_\d{5}/), 'id defaults to vjs_track_GUID');
 });
 
-test('kind can only be one of several options, defaults to empty string', function() {
-  let track = new AudioTrack({
+QUnit.test('kind can only be one of several options, defaults to empty string', function() {
+  const track1 = new AudioTrack({
     kind: 'foo'
   });
 
-  equal(track.kind, '', 'the kind is set to empty string, not foo');
-  notEqual(track.kind, 'foo', 'the kind is set to empty string, not foo');
+  QUnit.equal(track1.kind, '', 'the kind is set to empty string, not foo');
+  QUnit.notEqual(track1.kind, 'foo', 'the kind is set to empty string, not foo');
 
   // loop through all possible kinds to verify
-  for (let key in AudioTrackKind) {
-    let currentKind = AudioTrackKind[key];
-    let track = new AudioTrack({
-      kind: currentKind,
+  for (const key in AudioTrackKind) {
+    const currentKind = AudioTrackKind[key];
+    const track = new AudioTrack({
+      kind: currentKind
     });
-    equal(track.kind, currentKind, 'the kind is set to ' + currentKind);
+
+    QUnit.equal(track.kind, currentKind, 'the kind is set to ' + currentKind);
   }
 });
 
-test('enabled can only be instantiated to true or false, defaults to false', function() {
+QUnit.test('enabled can only be instantiated to true or false, defaults to false', function() {
   let track = new AudioTrack({
     enabled: 'foo'
   });
 
-  equal(track.enabled, false, 'the enabled value is set to false, not foo');
-  notEqual(track.enabled, 'foo', 'the enabled value is not set to foo');
+  QUnit.equal(track.enabled, false, 'the enabled value is set to false, not foo');
+  QUnit.notEqual(track.enabled, 'foo', 'the enabled value is not set to foo');
 
   track = new AudioTrack({
     enabled: true
   });
 
-  equal(track.enabled, true, 'the enabled value is set to true');
+  QUnit.equal(track.enabled, true, 'the enabled value is set to true');
 
   track = new AudioTrack({
     enabled: false
   });
 
-  equal(track.enabled, false, 'the enabled value is set to false');
+  QUnit.equal(track.enabled, false, 'the enabled value is set to false');
 });
 
-test('enabled can only be changed to true or false', function() {
-  let track = new AudioTrack();
+QUnit.test('enabled can only be changed to true or false', function() {
+  const track = new AudioTrack();
 
   track.enabled = 'foo';
-  notEqual(track.enabled, 'foo', 'enabled not set to invalid value, foo');
-  equal(track.enabled, false, 'enabled remains on the old value, false');
+  QUnit.notEqual(track.enabled, 'foo', 'enabled not set to invalid value, foo');
+  QUnit.equal(track.enabled, false, 'enabled remains on the old value, false');
 
   track.enabled = true;
-  equal(track.enabled, true, 'enabled was set to true');
+  QUnit.equal(track.enabled, true, 'enabled was set to true');
 
   track.enabled = 'baz';
-  notEqual(track.enabled, 'baz', 'enabled not set to invalid value, baz');
-  equal(track.enabled, true, 'enabled remains on the old value, true');
+  QUnit.notEqual(track.enabled, 'baz', 'enabled not set to invalid value, baz');
+  QUnit.equal(track.enabled, true, 'enabled remains on the old value, true');
 
   track.enabled = false;
-  equal(track.enabled, false, 'enabled was set to false');
+  QUnit.equal(track.enabled, false, 'enabled was set to false');
 });
 
-test('when enabled is changed enabledchange event is fired', function() {
-  let track = new AudioTrack({
+QUnit.test('when enabled is changed enabledchange event is fired', function() {
+  const track = new AudioTrack({
     tech: this.tech,
     enabled: false
   });
   let eventsTriggered = 0;
+
   track.addEventListener('enabledchange', () => {
     eventsTriggered++;
   });
@@ -100,19 +104,19 @@ test('when enabled is changed enabledchange event is fired', function() {
   // two events
   track.enabled = true;
   track.enabled = false;
-  equal(eventsTriggered, 2, 'two enabled changes');
+  QUnit.equal(eventsTriggered, 2, 'two enabled changes');
 
   // no event here
   track.enabled = false;
   track.enabled = false;
-  equal(eventsTriggered, 2, 'still two enabled changes');
+  QUnit.equal(eventsTriggered, 2, 'still two enabled changes');
 
   // one event
   track.enabled = true;
-  equal(eventsTriggered, 3, 'three enabled changes');
+  QUnit.equal(eventsTriggered, 3, 'three enabled changes');
 
   // no events
   track.enabled = true;
   track.enabled = true;
-  equal(eventsTriggered, 3, 'still three enabled changes');
+  QUnit.equal(eventsTriggered, 3, 'still three enabled changes');
 });
diff --git a/test/unit/tracks/audio-tracks.test.js b/test/unit/tracks/audio-tracks.test.js
index 7a4b67475..623290caa 100644
--- a/test/unit/tracks/audio-tracks.test.js
+++ b/test/unit/tracks/audio-tracks.test.js
@@ -1,13 +1,9 @@
-import AudioTrack from '../../../src/js/tracks/text-track.js';
+/* eslint-env qunit */
 import Html5 from '../../../src/js/tech/html5.js';
-import Tech from '../../../src/js/tech/tech.js';
-import Component from '../../../src/js/component.js';
-
-import * as browser from '../../../src/js/utils/browser.js';
 import TestHelpers from '../test-helpers.js';
-import document from 'global/document';
+import sinon from 'sinon';
 
-q.module('Tracks', {
+QUnit.module('Tracks', {
   setup() {
     this.clock = sinon.useFakeTimers();
   },
@@ -16,29 +12,24 @@ q.module('Tracks', {
   }
 });
 
-test('Player track methods call the tech', function() {
-  let player;
+QUnit.test('Player track methods call the tech', function() {
+  const player = TestHelpers.makePlayer();
   let calls = 0;
 
-  player = TestHelpers.makePlayer();
-
   player.tech_.audioTracks = function() {
     calls++;
   };
 
   player.audioTracks();
 
-  equal(calls, 1, 'audioTrack defers to the tech');
+  QUnit.equal(calls, 1, 'audioTrack defers to the tech');
   player.dispose();
 });
 
-test('listen to remove and add track events in native audio tracks', function() {
-  let oldTestVid = Html5.TEST_VID;
-  let player;
-  let options;
-  let oldAudioTracks = Html5.prototype.audioTracks;
-  let events = {};
-  let html;
+QUnit.test('listen to remove and add track events in native audio tracks', function() {
+  const oldTestVid = Html5.TEST_VID;
+  const oldAudioTracks = Html5.prototype.audioTracks;
+  const events = {};
 
   Html5.prototype.audioTracks = function() {
     return {
@@ -52,7 +43,7 @@ test('listen to remove and add track events in native audio tracks', function()
     audioTracks: []
   };
 
-  player = {
+  const player = {
     // Function.prototype is a built-in no-op function.
     controls() {},
     ready() {},
@@ -68,47 +59,51 @@ test('listen to remove and add track events in native audio tracks', function()
       };
     }
   };
+
   player.player_ = player;
-  player.options_ = options = {};
+  player.options_ = {};
 
-  html = new Html5(options);
+  /* eslint-disable no-unused-vars */
+  const html = new Html5({});
+  /* eslint-enable no-unused-vars */
 
-  ok(events.removetrack, 'removetrack listener was added');
-  ok(events.addtrack, 'addtrack listener was added');
+  QUnit.ok(events.removetrack, 'removetrack listener was added');
+  QUnit.ok(events.addtrack, 'addtrack listener was added');
 
   Html5.TEST_VID = oldTestVid;
   Html5.prototype.audioTracks = oldAudioTracks;
 });
 
-test('html5 tech supports native audio tracks if the video supports it', function() {
-  let oldTestVid = Html5.TEST_VID;
+QUnit.test('html5 tech supports native audio tracks if the video supports it', function() {
+  const oldTestVid = Html5.TEST_VID;
 
   Html5.TEST_VID = {
     audioTracks: []
   };
 
-  ok(Html5.supportsNativeAudioTracks(), 'native audio tracks are supported');
+  QUnit.ok(Html5.supportsNativeAudioTracks(), 'native audio tracks are supported');
 
   Html5.TEST_VID = oldTestVid;
 });
 
-test('html5 tech does not support native audio tracks if the video does not supports it', function() {
-  let oldTestVid = Html5.TEST_VID;
+QUnit.test('html5 tech does not support native audio tracks if the video does not supports it', function() {
+  const oldTestVid = Html5.TEST_VID;
+
   Html5.TEST_VID = {};
 
-  ok(!Html5.supportsNativeAudioTracks(), 'native audio tracks are not supported');
+  QUnit.ok(!Html5.supportsNativeAudioTracks(), 'native audio tracks are not supported');
 
   Html5.TEST_VID = oldTestVid;
 });
 
-test('when switching techs, we should not get a new audio track', function() {
-  let player = TestHelpers.makePlayer();
+QUnit.test('when switching techs, we should not get a new audio track', function() {
+  const player = TestHelpers.makePlayer();
 
   player.loadTech_('TechFaker');
-  let firstTracks = player.audioTracks();
+  const firstTracks = player.audioTracks();
 
   player.loadTech_('TechFaker');
-  let secondTracks = player.audioTracks();
+  const secondTracks = player.audioTracks();
 
-  ok(firstTracks === secondTracks, 'the tracks are equal');
+  QUnit.ok(firstTracks === secondTracks, 'the tracks are equal');
 });
diff --git a/test/unit/tracks/html-track-element-list.test.js b/test/unit/tracks/html-track-element-list.test.js
index 6a69aff4a..550578006 100644
--- a/test/unit/tracks/html-track-element-list.test.js
+++ b/test/unit/tracks/html-track-element-list.test.js
@@ -1,4 +1,4 @@
-import HTMLTrackElement from '../../../src/js/tracks/html-track-element.js';
+/* eslint-env qunit */
 import HTMLTrackElementList from '../../../src/js/tracks/html-track-element-list.js';
 import TextTrack from '../../../src/js/tracks/text-track.js';
 
@@ -28,31 +28,47 @@ const genericHtmlTrackElements = [{
   track: track2
 }];
 
-q.module('HTML Track Element List');
+QUnit.module('HTML Track Element List');
 
-test('HTMLTrackElementList\'s length is set correctly', function() {
-  let htmlTrackElementList = new HTMLTrackElementList(genericHtmlTrackElements);
+QUnit.test('HTMLTrackElementList\'s length is set correctly', function() {
+  const htmlTrackElementList = new HTMLTrackElementList(genericHtmlTrackElements);
 
-  equal(htmlTrackElementList.length, genericHtmlTrackElements.length, `the length is ${genericHtmlTrackElements.length}`);
+  QUnit.equal(htmlTrackElementList.length,
+              genericHtmlTrackElements.length,
+              `the length is ${genericHtmlTrackElements.length}`);
 });
 
-test('can get html track element by track', function() {
-  let htmlTrackElementList = new HTMLTrackElementList(genericHtmlTrackElements);
+QUnit.test('can get html track element by track', function() {
+  const htmlTrackElementList = new HTMLTrackElementList(genericHtmlTrackElements);
 
-  equal(htmlTrackElementList.getTrackElementByTrack_(track1).kind, 'captions', 'track1 has kind of captions');
-  equal(htmlTrackElementList.getTrackElementByTrack_(track2).kind, 'chapters', 'track2 has kind of captions');
+  QUnit.equal(htmlTrackElementList.getTrackElementByTrack_(track1).kind,
+              'captions',
+              'track1 has kind of captions');
+  QUnit.equal(htmlTrackElementList.getTrackElementByTrack_(track2).kind,
+              'chapters',
+              'track2 has kind of captions');
 });
 
-test('length is updated when new tracks are added or removed', function() {
-  let htmlTrackElementList = new HTMLTrackElementList(genericHtmlTrackElements);
+QUnit.test('length is updated when new tracks are added or removed', function() {
+  const htmlTrackElementList = new HTMLTrackElementList(genericHtmlTrackElements);
 
   htmlTrackElementList.addTrackElement_({tech() {}});
-  equal(htmlTrackElementList.length, genericHtmlTrackElements.length + 1, `the length is ${genericHtmlTrackElements.length + 1}`);
+  QUnit.equal(htmlTrackElementList.length,
+              genericHtmlTrackElements.length + 1,
+              `the length is ${genericHtmlTrackElements.length + 1}`);
   htmlTrackElementList.addTrackElement_({tech() {}});
-  equal(htmlTrackElementList.length, genericHtmlTrackElements.length + 2, `the length is ${genericHtmlTrackElements.length + 2}`);
+  QUnit.equal(htmlTrackElementList.length,
+              genericHtmlTrackElements.length + 2,
+              `the length is ${genericHtmlTrackElements.length + 2}`);
 
-  htmlTrackElementList.removeTrackElement_(htmlTrackElementList.getTrackElementByTrack_(track1));
-  equal(htmlTrackElementList.length, genericHtmlTrackElements.length + 1, `the length is ${genericHtmlTrackElements.length + 1}`);
-  htmlTrackElementList.removeTrackElement_(htmlTrackElementList.getTrackElementByTrack_(track2));
-  equal(htmlTrackElementList.length, genericHtmlTrackElements.length, `the length is ${genericHtmlTrackElements.length}`);
+  htmlTrackElementList.removeTrackElement_(
+    htmlTrackElementList.getTrackElementByTrack_(track1));
+  QUnit.equal(htmlTrackElementList.length,
+              genericHtmlTrackElements.length + 1,
+              `the length is ${genericHtmlTrackElements.length + 1}`);
+  htmlTrackElementList.removeTrackElement_(
+    htmlTrackElementList.getTrackElementByTrack_(track2));
+  QUnit.equal(htmlTrackElementList.length,
+              genericHtmlTrackElements.length,
+              `the length is ${genericHtmlTrackElements.length}`);
 });
diff --git a/test/unit/tracks/html-track-element.test.js b/test/unit/tracks/html-track-element.test.js
index 063f0f928..019aa7aa5 100644
--- a/test/unit/tracks/html-track-element.test.js
+++ b/test/unit/tracks/html-track-element.test.js
@@ -1,5 +1,5 @@
+/* eslint-env qunit */
 import HTMLTrackElement from '../../../src/js/tracks/html-track-element.js';
-import TextTrack from '../../../src/js/tracks/text-track.js';
 import window from 'global/window';
 
 const defaultTech = {
@@ -9,25 +9,25 @@ const defaultTech = {
   currentTime() {}
 };
 
-q.module('HTML Track Element');
+QUnit.module('HTML Track Element');
 
-test('html track element requires a tech', function() {
+QUnit.test('html track element requires a tech', function() {
   window.throws(
     function() {
-      new HTMLTrackElement();
+      return new HTMLTrackElement();
     },
     new Error('A tech was not provided.'),
     'a tech is required for html track element'
   );
 });
 
-test('can create a html track element with various properties', function() {
-  let kind = 'chapters';
-  let label = 'English';
-  let language = 'en';
-  let src = 'http://www.example.com';
+QUnit.test('can create a html track element with various properties', function() {
+  const kind = 'chapters';
+  const label = 'English';
+  const language = 'en';
+  const src = 'http://www.example.com';
 
-  let htmlTrackElement = new HTMLTrackElement({
+  const htmlTrackElement = new HTMLTrackElement({
     kind,
     label,
     language,
@@ -35,38 +35,35 @@ test('can create a html track element with various properties', function() {
     tech: defaultTech
   });
 
-  equal(typeof htmlTrackElement.default, 'undefined', 'we have a default');
-  equal(htmlTrackElement.kind, kind, 'we have a kind');
-  equal(htmlTrackElement.label, label, 'we have a label');
-  equal(htmlTrackElement.readyState, 0, 'we have a readyState');
-  equal(htmlTrackElement.src, src, 'we have a src');
-  equal(htmlTrackElement.srclang, language, 'we have a srclang');
-  equal(htmlTrackElement.track.cues, null, 'we have a track');
+  QUnit.equal(typeof htmlTrackElement.default, 'undefined', 'we have a default');
+  QUnit.equal(htmlTrackElement.kind, kind, 'we have a kind');
+  QUnit.equal(htmlTrackElement.label, label, 'we have a label');
+  QUnit.equal(htmlTrackElement.readyState, 0, 'we have a readyState');
+  QUnit.equal(htmlTrackElement.src, src, 'we have a src');
+  QUnit.equal(htmlTrackElement.srclang, language, 'we have a srclang');
+  QUnit.equal(htmlTrackElement.track.cues, null, 'we have a track');
 });
 
-test('defaults when items not provided', function() {
-  let htmlTrackElement = new HTMLTrackElement({
+QUnit.test('defaults when items not provided', function() {
+  const htmlTrackElement = new HTMLTrackElement({
     tech: defaultTech
   });
 
-  equal(typeof htmlTrackElement.default, 'undefined', 'we have a default');
-  equal(htmlTrackElement.kind, 'subtitles', 'we have a kind');
-  equal(htmlTrackElement.label, '', 'we have a label');
-  equal(htmlTrackElement.readyState, 0, 'we have a readyState');
-  equal(typeof htmlTrackElement.src, 'undefined', 'we have a src');
-  equal(htmlTrackElement.srclang, '', 'we have a srclang');
-  equal(htmlTrackElement.track.cues.length, 0, 'we have a track');
+  QUnit.equal(typeof htmlTrackElement.default, 'undefined', 'we have a default');
+  QUnit.equal(htmlTrackElement.kind, 'subtitles', 'we have a kind');
+  QUnit.equal(htmlTrackElement.label, '', 'we have a label');
+  QUnit.equal(htmlTrackElement.readyState, 0, 'we have a readyState');
+  QUnit.equal(typeof htmlTrackElement.src, 'undefined', 'we have a src');
+  QUnit.equal(htmlTrackElement.srclang, '', 'we have a srclang');
+  QUnit.equal(htmlTrackElement.track.cues.length, 0, 'we have a track');
 });
 
-test('fires loadeddata when track cues become populated', function() {
+QUnit.test('fires loadeddata when track cues become populated', function() {
   let changes = 0;
-  let loadHandler;
-
-  loadHandler = function() {
+  const loadHandler = function() {
     changes++;
   };
-
-  let htmlTrackElement = new HTMLTrackElement({
+  const htmlTrackElement = new HTMLTrackElement({
     tech() {}
   });
 
@@ -75,6 +72,6 @@ test('fires loadeddata when track cues become populated', function() {
   // trigger loaded cues event
   htmlTrackElement.track.trigger('loadeddata');
 
-  equal(changes, 1, 'a loadeddata event trigger addEventListener');
-  equal(htmlTrackElement.readyState, 2, 'readyState is loaded');
+  QUnit.equal(changes, 1, 'a loadeddata event trigger addEventListener');
+  QUnit.equal(htmlTrackElement.readyState, 2, 'readyState is loaded');
 });
diff --git a/test/unit/tracks/text-track-controls.test.js b/test/unit/tracks/text-track-controls.test.js
index 27aa44252..80e258282 100644
--- a/test/unit/tracks/text-track-controls.test.js
+++ b/test/unit/tracks/text-track-controls.test.js
@@ -1,8 +1,10 @@
+/* eslint-env qunit */
 import TextTrackMenuItem from '../../../src/js/control-bar/text-track-controls/text-track-menu-item.js';
 import TestHelpers from '../test-helpers.js';
 import * as browser from '../../../src/js/utils/browser.js';
+import sinon from 'sinon';
 
-q.module('Text Track Controls', {
+QUnit.module('Text Track Controls', {
   setup() {
     this.clock = sinon.useFakeTimers();
   },
@@ -16,72 +18,77 @@ const track = {
   label: 'test'
 };
 
-test('should be displayed when text tracks list is not empty', function() {
-  let player = TestHelpers.makePlayer({
+QUnit.test('should be displayed when text tracks list is not empty', function() {
+  const player = TestHelpers.makePlayer({
     tracks: [track]
   });
 
   this.clock.tick(1000);
 
-  ok(!player.controlBar.captionsButton.hasClass('vjs-hidden'), 'control is displayed');
-  equal(player.textTracks().length, 1, 'textTracks contains one item');
+  QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-hidden'),
+           'control is displayed');
+  QUnit.equal(player.textTracks().length, 1, 'textTracks contains one item');
 
   player.dispose();
 });
 
-test('should be displayed when a text track is added to an empty track list', function() {
-  let player = TestHelpers.makePlayer();
+QUnit.test('should be displayed when a text track is added to an empty track list', function() {
+  const player = TestHelpers.makePlayer();
 
   player.addRemoteTextTrack(track);
 
-  ok(!player.controlBar.captionsButton.hasClass('vjs-hidden'), 'control is displayed');
-  equal(player.textTracks().length, 1, 'textTracks contains one item');
+  QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-hidden'),
+           'control is displayed');
+  QUnit.equal(player.textTracks().length, 1, 'textTracks contains one item');
 
   player.dispose();
 });
 
-test('should not be displayed when text tracks list is empty', function() {
-  let player = TestHelpers.makePlayer();
+QUnit.test('should not be displayed when text tracks list is empty', function() {
+  const player = TestHelpers.makePlayer();
 
-  ok(player.controlBar.captionsButton.hasClass('vjs-hidden'), 'control is not displayed');
-  equal(player.textTracks().length, 0, 'textTracks is empty');
+  QUnit.ok(player.controlBar.captionsButton.hasClass('vjs-hidden'),
+           'control is not displayed');
+  QUnit.equal(player.textTracks().length, 0, 'textTracks is empty');
 
   player.dispose();
 });
 
-test('should not be displayed when last text track is removed', function() {
-  let player = TestHelpers.makePlayer({
+QUnit.test('should not be displayed when last text track is removed', function() {
+  const player = TestHelpers.makePlayer({
     tracks: [track]
   });
 
   player.removeRemoteTextTrack(player.textTracks()[0]);
 
-  ok(player.controlBar.captionsButton.hasClass('vjs-hidden'), 'control is not displayed');
-  equal(player.textTracks().length, 0, 'textTracks is empty');
+  QUnit.ok(player.controlBar.captionsButton.hasClass('vjs-hidden'),
+           'control is not displayed');
+  QUnit.equal(player.textTracks().length, 0, 'textTracks is empty');
 
   player.dispose();
 });
 
-test('menu should contain "Settings", "Off" and one track', function() {
-  let player = TestHelpers.makePlayer({
+QUnit.test('menu should contain "Settings", "Off" and one track', function() {
+  const player = TestHelpers.makePlayer({
     tracks: [track]
   });
-  let menuItems;
 
   this.clock.tick(1000);
 
-  menuItems = player.controlBar.captionsButton.items;
+  const menuItems = player.controlBar.captionsButton.items;
 
-  equal(menuItems.length, 3, 'menu contains three items');
-  equal(menuItems[0].track.label, 'captions settings', 'menu contains "captions settings"');
-  equal(menuItems[1].track.label, 'captions off', 'menu contains "captions off"');
-  equal(menuItems[2].track.label, 'test', 'menu contains "test" track');
+  QUnit.equal(menuItems.length, 3, 'menu contains three items');
+  QUnit.equal(menuItems[0].track.label,
+              'captions settings',
+              'menu contains "captions settings"');
+  QUnit.equal(menuItems[1].track.label, 'captions off', 'menu contains "captions off"');
+  QUnit.equal(menuItems[2].track.label, 'test', 'menu contains "test" track');
 
   player.dispose();
 });
 
-test('menu should update with addRemoteTextTrack', function() {
-  let player = TestHelpers.makePlayer({
+QUnit.test('menu should update with addRemoteTextTrack', function() {
+  const player = TestHelpers.makePlayer({
     tracks: [track]
   });
 
@@ -89,14 +96,16 @@ test('menu should update with addRemoteTextTrack', function() {
 
   player.addRemoteTextTrack(track);
 
-  equal(player.controlBar.captionsButton.items.length, 4, 'menu does contain added track');
-  equal(player.textTracks().length, 2, 'textTracks contains two items');
+  QUnit.equal(player.controlBar.captionsButton.items.length,
+              4,
+              'menu does contain added track');
+  QUnit.equal(player.textTracks().length, 2, 'textTracks contains two items');
 
   player.dispose();
 });
 
-test('menu should update with removeRemoteTextTrack', function() {
-  let player = TestHelpers.makePlayer({
+QUnit.test('menu should update with removeRemoteTextTrack', function() {
+  const player = TestHelpers.makePlayer({
     tracks: [track, track]
   });
 
@@ -104,148 +113,171 @@ test('menu should update with removeRemoteTextTrack', function() {
 
   player.removeRemoteTextTrack(player.textTracks()[0]);
 
-  equal(player.controlBar.captionsButton.items.length, 3, 'menu does not contain removed track');
-  equal(player.textTracks().length, 1, 'textTracks contains one item');
+  QUnit.equal(player.controlBar.captionsButton.items.length,
+              3,
+              'menu does not contain removed track');
+  QUnit.equal(player.textTracks().length, 1, 'textTracks contains one item');
 
   player.dispose();
 });
 
-let descriptionstrack = {
+const descriptionstrack = {
   kind: 'descriptions',
   label: 'desc'
 };
 
-test('descriptions should be displayed when text tracks list is not empty', function() {
-  let player = TestHelpers.makePlayer({
+QUnit.test('descriptions should be displayed when text tracks list is not empty', function() {
+  const player = TestHelpers.makePlayer({
     tracks: [descriptionstrack]
   });
 
   this.clock.tick(1000);
 
-  ok(!player.controlBar.descriptionsButton.hasClass('vjs-hidden'), 'descriptions control is displayed');
-  equal(player.textTracks().length, 1, 'textTracks contains one item');
+  QUnit.ok(!player.controlBar.descriptionsButton.hasClass('vjs-hidden'),
+           'descriptions control is displayed');
+  QUnit.equal(player.textTracks().length, 1, 'textTracks contains one item');
 
   player.dispose();
 });
 
-test('descriptions should be displayed when a text track is added to an empty track list', function() {
-  let player = TestHelpers.makePlayer();
+QUnit.test('descriptions should be displayed when a text track is added to an empty track list', function() {
+  const player = TestHelpers.makePlayer();
 
   player.addRemoteTextTrack(descriptionstrack);
 
-  ok(!player.controlBar.descriptionsButton.hasClass('vjs-hidden'), 'control is displayed');
-  equal(player.textTracks().length, 1, 'textTracks contains one item');
+  QUnit.ok(!player.controlBar.descriptionsButton.hasClass('vjs-hidden'),
+           'control is displayed');
+  QUnit.equal(player.textTracks().length, 1, 'textTracks contains one item');
 
   player.dispose();
 });
 
-test('descriptions should not be displayed when text tracks list is empty', function() {
-  let player = TestHelpers.makePlayer();
+QUnit.test('descriptions should not be displayed when text tracks list is empty', function() {
+  const player = TestHelpers.makePlayer();
 
-  ok(player.controlBar.descriptionsButton.hasClass('vjs-hidden'), 'control is not displayed');
-  equal(player.textTracks().length, 0, 'textTracks is empty');
+  QUnit.ok(player.controlBar.descriptionsButton.hasClass('vjs-hidden'),
+           'control is not displayed');
+  QUnit.equal(player.textTracks().length, 0, 'textTracks is empty');
 
   player.dispose();
 });
 
-test('descriptions should not be displayed when last text track is removed', function() {
-  let player = TestHelpers.makePlayer({
+QUnit.test('descriptions should not be displayed when last text track is removed', function() {
+  const player = TestHelpers.makePlayer({
     tracks: [descriptionstrack]
   });
 
   player.removeRemoteTextTrack(player.textTracks()[0]);
 
-  ok(player.controlBar.descriptionsButton.hasClass('vjs-hidden'), 'control is not displayed');
-  equal(player.textTracks().length, 0, 'textTracks is empty');
+  QUnit.ok(player.controlBar.descriptionsButton.hasClass('vjs-hidden'),
+           'control is not displayed');
+  QUnit.equal(player.textTracks().length, 0, 'textTracks is empty');
 
   player.dispose();
 });
 
-test('descriptions menu should contain "Off" and one track', function() {
-  let player = TestHelpers.makePlayer({
-      tracks: [descriptionstrack]
-    }),
-    menuItems;
+QUnit.test('descriptions menu should contain "Off" and one track', function() {
+  const player = TestHelpers.makePlayer({
+    tracks: [descriptionstrack]
+  });
 
   this.clock.tick(1000);
 
-  menuItems = player.controlBar.descriptionsButton.items;
+  const menuItems = player.controlBar.descriptionsButton.items;
 
-  equal(menuItems.length, 2, 'descriptions menu contains two items');
-  equal(menuItems[0].track.label, 'descriptions off', 'menu contains "descriptions off"');
-  equal(menuItems[1].track.label, 'desc', 'menu contains "desc" track');
+  QUnit.equal(menuItems.length, 2, 'descriptions menu contains two items');
+  QUnit.equal(menuItems[0].track.label,
+              'descriptions off',
+              'menu contains "descriptions off"');
+  QUnit.equal(menuItems[1].track.label, 'desc', 'menu contains "desc" track');
 
   player.dispose();
 });
 
-test('enabling a captions track should disable the descriptions menu button', function() {
-  expect(14);
+QUnit.test('enabling a captions track should disable the descriptions menu button', function() {
+  QUnit.expect(14);
 
-  let player = TestHelpers.makePlayer({
+  const player = TestHelpers.makePlayer({
     tracks: [track, descriptionstrack]
   });
 
   this.clock.tick(1000);
 
-  ok(!player.controlBar.captionsButton.hasClass('vjs-hidden'), 'captions control is displayed');
-  ok(!player.controlBar.descriptionsButton.hasClass('vjs-hidden'), 'descriptions control is displayed');
-  equal(player.textTracks().length, 2, 'textTracks contains two items');
+  QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-hidden'),
+           'captions control is displayed');
+  QUnit.ok(!player.controlBar.descriptionsButton.hasClass('vjs-hidden'),
+           'descriptions control is displayed');
+  QUnit.equal(player.textTracks().length, 2, 'textTracks contains two items');
 
-  ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'), 'captions control is NOT disabled');
-  ok(!player.controlBar.descriptionsButton.hasClass('vjs-disabled'), 'descriptions control is NOT disabled');
+  QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'),
+           'captions control is NOT disabled');
+  QUnit.ok(!player.controlBar.descriptionsButton.hasClass('vjs-disabled'),
+           'descriptions control is NOT disabled');
 
   for (let i = 0; i < player.textTracks().length; i++) {
     if (player.textTracks()[i].kind === 'descriptions') {
       player.textTracks()[i].mode = 'showing';
-      ok(player.textTracks()[i].kind === 'descriptions' && player.textTracks()[i].mode === 'showing', 'descriptions mode set to showing');
+      QUnit.ok(player.textTracks()[i].kind === 'descriptions' &&
+               player.textTracks()[i].mode === 'showing',
+               'descriptions mode set to showing');
     }
   }
 
   this.clock.tick(1000);
 
-  ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'), 'captions control is NOT disabled');
-  ok(!player.controlBar.descriptionsButton.hasClass('vjs-disabled'), 'descriptions control is NOT disabled');
+  QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'),
+           'captions control is NOT disabled');
+  QUnit.ok(!player.controlBar.descriptionsButton.hasClass('vjs-disabled'),
+           'descriptions control is NOT disabled');
 
   for (let i = 0; i < player.textTracks().length; i++) {
     if (player.textTracks()[i].kind === 'captions') {
       player.textTracks()[i].mode = 'showing';
-      ok(player.textTracks()[i].kind === 'captions' && player.textTracks()[i].mode === 'showing', 'captions mode set to showing');
+      QUnit.ok(player.textTracks()[i].kind === 'captions' &&
+               player.textTracks()[i].mode === 'showing',
+               'captions mode set to showing');
     }
   }
 
   this.clock.tick(1000);
 
-  ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'), 'captions control is NOT disabled');
-  ok(player.controlBar.descriptionsButton.hasClass('vjs-disabled'), 'descriptions control IS disabled');
+  QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'),
+           'captions control is NOT disabled');
+  QUnit.ok(player.controlBar.descriptionsButton.hasClass('vjs-disabled'),
+           'descriptions control IS disabled');
 
   for (let i = 0; i < player.textTracks().length; i++) {
     if (player.textTracks()[i].kind === 'captions') {
       player.textTracks()[i].mode = 'disabled';
-      ok(player.textTracks()[i].kind === 'captions' && player.textTracks()[i].mode === 'disabled', 'captions mode set to disabled');
+      QUnit.ok(player.textTracks()[i].kind === 'captions' &&
+               player.textTracks()[i].mode === 'disabled',
+               'captions mode set to disabled');
     }
   }
 
   this.clock.tick(1000);
 
-  ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'), 'captions control is NOT disabled');
-  ok(!player.controlBar.descriptionsButton.hasClass('vjs-disabled'), 'descriptions control is NOT disabled');
+  QUnit.ok(!player.controlBar.captionsButton.hasClass('vjs-disabled'),
+           'captions control is NOT disabled');
+  QUnit.ok(!player.controlBar.descriptionsButton.hasClass('vjs-disabled'),
+           'descriptions control is NOT disabled');
 
   player.dispose();
 });
 
 if (!browser.IS_IE8) {
   // This test doesn't work on IE8.
-  // However, this test tests a specific with iOS7 where the TextTrackList doesn't report track mode changes.
+  // However, this test tests a specific with iOS7 where
+  // the TextTrackList doesn't report track mode changes.
   // TODO: figure out why this test doens't work on IE8. https://github.com/videojs/video.js/issues/1861
-  test('menu items should polyfill mode change events', function() {
-    let player = TestHelpers.makePlayer({});
+  QUnit.test('menu items should polyfill mode change events', function() {
+    const player = TestHelpers.makePlayer({});
     let changes;
-    let trackMenuItem;
 
     // emulate a TextTrackList that doesn't report track mode changes,
     // like iOS7
     player.textTracks().onchange = undefined;
-    trackMenuItem = new TextTrackMenuItem(player, {
+    const trackMenuItem = new TextTrackMenuItem(player, {
       track
     });
 
@@ -254,10 +286,10 @@ if (!browser.IS_IE8) {
     });
     changes = 0;
     trackMenuItem.trigger('tap');
-    equal(changes, 1, 'taps trigger change events');
+    QUnit.equal(changes, 1, 'taps trigger change events');
 
     trackMenuItem.trigger('click');
-    equal(changes, 2, 'clicks trigger change events');
+    QUnit.equal(changes, 2, 'clicks trigger change events');
 
     player.dispose();
   });
diff --git a/test/unit/tracks/text-track-cue-list.test.js b/test/unit/tracks/text-track-cue-list.test.js
index fdcceba5b..163aae7fd 100644
--- a/test/unit/tracks/text-track-cue-list.test.js
+++ b/test/unit/tracks/text-track-cue-list.test.js
@@ -1,3 +1,4 @@
+/* eslint-env qunit */
 import TextTrackCueList from '../../../src/js/tracks/text-track-cue-list.js';
 
 const genericTracks = [
@@ -10,81 +11,83 @@ const genericTracks = [
   }
 ];
 
-q.module('Text Track Cue List');
+QUnit.module('Text Track Cue List');
 
-test('TextTrackCueList\'s length is set correctly', function() {
-  let ttcl = new TextTrackCueList(genericTracks);
+QUnit.test('TextTrackCueList\'s length is set correctly', function() {
+  const ttcl = new TextTrackCueList(genericTracks);
 
-  equal(ttcl.length, genericTracks.length, 'the length is ' + genericTracks.length);
+  QUnit.equal(ttcl.length, genericTracks.length, 'the length is ' + genericTracks.length);
 });
 
-test('can get cues by id', function() {
-  let ttcl = new TextTrackCueList(genericTracks);
+QUnit.test('can get cues by id', function() {
+  const ttcl = new TextTrackCueList(genericTracks);
 
-  equal(ttcl.getCueById('1').id, 1, 'id "1" has id of "1"');
-  equal(ttcl.getCueById('2').id, 2, 'id "2" has id of "2"');
-  equal(ttcl.getCueById('3').id, 3, 'id "3" has id of "3"');
-  ok(!ttcl.getCueById(1), 'there isn\'t an item with "numeric" id of `1`');
+  QUnit.equal(ttcl.getCueById('1').id, 1, 'id "1" has id of "1"');
+  QUnit.equal(ttcl.getCueById('2').id, 2, 'id "2" has id of "2"');
+  QUnit.equal(ttcl.getCueById('3').id, 3, 'id "3" has id of "3"');
+  QUnit.ok(!ttcl.getCueById(1), 'there isn\'t an item with "numeric" id of `1`');
 });
 
-test('length is updated when new tracks are added or removed', function() {
-  let ttcl = new TextTrackCueList(genericTracks);
+QUnit.test('length is updated when new tracks are added or removed', function() {
+  const ttcl = new TextTrackCueList(genericTracks);
 
   ttcl.setCues_(genericTracks.concat([{id: '100'}]));
-  equal(ttcl.length, genericTracks.length + 1, 'the length is ' + (genericTracks.length + 1));
+  QUnit.equal(ttcl.length, genericTracks.length + 1,
+              'the length is ' + (genericTracks.length + 1));
   ttcl.setCues_(genericTracks.concat([{id: '100'}, {id: '101'}]));
-  equal(ttcl.length, genericTracks.length + 2, 'the length is ' + (genericTracks.length + 2));
+  QUnit.equal(ttcl.length, genericTracks.length + 2,
+              'the length is ' + (genericTracks.length + 2));
 
   ttcl.setCues_(genericTracks.concat([{id: '100'}]));
-  equal(ttcl.length, genericTracks.length + 1, 'the length is ' + (genericTracks.length + 1));
+  QUnit.equal(ttcl.length, genericTracks.length + 1,
+              'the length is ' + (genericTracks.length + 1));
   ttcl.setCues_(genericTracks);
-  equal(ttcl.length, genericTracks.length, 'the length is ' + genericTracks.length);
+  QUnit.equal(ttcl.length, genericTracks.length, 'the length is ' + genericTracks.length);
 });
 
-test('can access items by index', function() {
-  let ttcl = new TextTrackCueList(genericTracks);
-  let i = 0;
-  let length = ttcl.length;
+QUnit.test('can access items by index', function() {
+  const ttcl = new TextTrackCueList(genericTracks);
+  const length = ttcl.length;
 
-  expect(length);
+  QUnit.expect(length);
 
-  for (; i < length; i++) {
-    equal(ttcl[i].id, String(i + 1), 'the id of a track matches the index + 1');
+  for (let i = 0; i < length; i++) {
+    QUnit.equal(ttcl[i].id, String(i + 1), 'the id of a track matches the index + 1');
   }
 });
 
-test('can access new items by index', function() {
-  let ttcl = new TextTrackCueList(genericTracks);
+QUnit.test('can access new items by index', function() {
+  const ttcl = new TextTrackCueList(genericTracks);
 
   ttcl.setCues_(genericTracks.concat([{id: '100'}]));
 
-  equal(ttcl[3].id, '100', 'id of item at index 3 is 100');
+  QUnit.equal(ttcl[3].id, '100', 'id of item at index 3 is 100');
   ttcl.setCues_(genericTracks.concat([{id: '100'}, {id: '101'}]));
-  equal(ttcl[4].id, '101', 'id of item at index 4 is 101');
+  QUnit.equal(ttcl[4].id, '101', 'id of item at index 4 is 101');
 });
 
-test('cannot access removed items by index', function() {
-  let ttcl = new TextTrackCueList(genericTracks);
+QUnit.test('cannot access removed items by index', function() {
+  const ttcl = new TextTrackCueList(genericTracks);
 
   ttcl.setCues_(genericTracks.concat([{id: '100'}, {id: '101'}]));
-  equal(ttcl[3].id, '100', 'id of item at index 3 is 100');
-  equal(ttcl[4].id, '101', 'id of item at index 4 is 101');
+  QUnit.equal(ttcl[3].id, '100', 'id of item at index 3 is 100');
+  QUnit.equal(ttcl[4].id, '101', 'id of item at index 4 is 101');
 
   ttcl.setCues_(genericTracks);
 
-  ok(!ttcl[3], 'nothing at index 3');
-  ok(!ttcl[4], 'nothing at index 4');
+  QUnit.ok(!ttcl[3], 'nothing at index 3');
+  QUnit.ok(!ttcl[4], 'nothing at index 4');
 });
 
-test('new item available at old index', function() {
-  let ttcl = new TextTrackCueList(genericTracks);
+QUnit.test('new item available at old index', function() {
+  const ttcl = new TextTrackCueList(genericTracks);
 
   ttcl.setCues_(genericTracks.concat([{id: '100'}]));
-  equal(ttcl[3].id, '100', 'id of item at index 3 is 100');
+  QUnit.equal(ttcl[3].id, '100', 'id of item at index 3 is 100');
 
   ttcl.setCues_(genericTracks);
-  ok(!ttcl[3], 'nothing at index 3');
+  QUnit.ok(!ttcl[3], 'nothing at index 3');
 
   ttcl.setCues_(genericTracks.concat([{id: '101'}]));
-  equal(ttcl[3].id, '101', 'id of new item at index 3 is now 101');
+  QUnit.equal(ttcl[3].id, '101', 'id of new item at index 3 is now 101');
 });
diff --git a/test/unit/tracks/text-track-list-converter.test.js b/test/unit/tracks/text-track-list-converter.test.js
index b1696f489..e8251c05b 100644
--- a/test/unit/tracks/text-track-list-converter.test.js
+++ b/test/unit/tracks/text-track-list-converter.test.js
@@ -1,10 +1,11 @@
+/* eslint-env qunit */
 import c from '../../../src/js/tracks/text-track-list-converter.js';
 import TextTrack from '../../../src/js/tracks/text-track.js';
 import TextTrackList from '../../../src/js/tracks/text-track-list.js';
 import Html5 from '../../../src/js/tech/html5.js';
 import document from 'global/document';
 
-q.module('Text Track List Converter', {});
+QUnit.module('Text Track List Converter', {});
 
 let clean = (item) => {
   delete item.id;
@@ -23,7 +24,7 @@ let cleanup = (item) => {
 };
 
 if (Html5.supportsNativeTextTracks()) {
-  q.test('trackToJson_ produces correct representation for native track object', function(a) {
+  QUnit.test('trackToJson_ produces correct representation for native track object', function(a) {
     let track = document.createElement('track');
 
     track.src = 'example.com/english.vtt';
@@ -39,7 +40,7 @@ if (Html5.supportsNativeTextTracks()) {
     }, 'the json output is same');
   });
 
-  q.test('textTracksToJson produces good json output', function(a) {
+  QUnit.test('textTracksToJson produces good json output', function(a) {
     let emulatedTrack = new TextTrack({
       kind: 'captions',
       label: 'English',
@@ -88,7 +89,7 @@ if (Html5.supportsNativeTextTracks()) {
     }], 'the output is correct');
   });
 
-  q.test('jsonToTextTracks calls addRemoteTextTrack on the tech with mixed tracks', function(a) {
+  QUnit.test('jsonToTextTracks calls addRemoteTextTrack on the tech with mixed tracks', function(a) {
     let emulatedTrack = new TextTrack({
       kind: 'captions',
       label: 'English',
@@ -139,7 +140,7 @@ if (Html5.supportsNativeTextTracks()) {
   });
 }
 
-q.test('trackToJson_ produces correct representation for emulated track object', function(a) {
+QUnit.test('trackToJson_ produces correct representation for emulated track object', function(a) {
   let track = new TextTrack({
     kind: 'captions',
     label: 'English',
@@ -157,7 +158,7 @@ q.test('trackToJson_ produces correct representation for emulated track object',
   }, 'the json output is same');
 });
 
-q.test('textTracksToJson produces good json output for emulated only', function(a) {
+QUnit.test('textTracksToJson produces good json output for emulated only', function(a) {
   let emulatedTrack = new TextTrack({
     kind: 'captions',
     label: 'English',
@@ -211,7 +212,7 @@ q.test('textTracksToJson produces good json output for emulated only', function(
   }], 'the output is correct');
 });
 
-q.test('jsonToTextTracks calls addRemoteTextTrack on the tech with emulated tracks only', function(a) {
+QUnit.test('jsonToTextTracks calls addRemoteTextTrack on the tech with emulated tracks only', function(a) {
   let emulatedTrack = new TextTrack({
     kind: 'captions',
     label: 'English',
diff --git a/test/unit/tracks/text-track-list.test.js b/test/unit/tracks/text-track-list.test.js
index b56ee97f5..b42c8fafe 100644
--- a/test/unit/tracks/text-track-list.test.js
+++ b/test/unit/tracks/text-track-list.test.js
@@ -1,13 +1,14 @@
+/* eslint-env qunit */
 import TextTrackList from '../../../src/js/tracks/text-track-list.js';
 import TextTrack from '../../../src/js/tracks/text-track.js';
 import EventTarget from '../../../src/js/event-target.js';
 
-q.module('Text Track List');
-test('trigger "change" event when "modechange" is fired on a track', function() {
-  let tt = new EventTarget();
-  let ttl = new TextTrackList([tt]);
+QUnit.module('Text Track List');
+QUnit.test('trigger "change" event when "modechange" is fired on a track', function() {
+  const tt = new EventTarget();
+  const ttl = new TextTrackList([tt]);
   let changes = 0;
-  let changeHandler = function() {
+  const changeHandler = function() {
     changes++;
   };
 
@@ -18,18 +19,18 @@ test('trigger "change" event when "modechange" is fired on a track', function()
   ttl.onchange = changeHandler;
 
   tt.trigger('modechange');
-  equal(changes, 2, 'two change events should have fired');
+  QUnit.equal(changes, 2, 'two change events should have fired');
 });
 
-test('trigger "change" event when mode changes on a TextTrack', function() {
-  let tt = new TextTrack({
+QUnit.test('trigger "change" event when mode changes on a TextTrack', function() {
+  const tt = new TextTrack({
     tech: {
       on() {}
     }
   });
-  let ttl = new TextTrackList([tt]);
+  const ttl = new TextTrackList([tt]);
   let changes = 0;
-  let changeHandler = function() {
+  const changeHandler = function() {
     changes++;
   };
 
@@ -42,5 +43,5 @@ test('trigger "change" event when mode changes on a TextTrack', function() {
   tt.mode = 'hidden';
   tt.mode = 'disabled';
 
-  equal(changes, 3, 'three change events should have fired');
+  QUnit.equal(changes, 3, 'three change events should have fired');
 });
diff --git a/test/unit/tracks/text-track-settings.test.js b/test/unit/tracks/text-track-settings.test.js
index ce5e71584..5d99a9ff7 100644
--- a/test/unit/tracks/text-track-settings.test.js
+++ b/test/unit/tracks/text-track-settings.test.js
@@ -1,3 +1,4 @@
+/* eslint-env qunit */
 import TextTrackSettings from '../../../src/js/tracks/text-track-settings.js';
 import TestHelpers from '../test-helpers.js';
 import * as Events from '../../../src/js/utils/events.js';
@@ -10,23 +11,23 @@ const tracks = [{
 }];
 
 const defaultSettings = {
-    backgroundColor: '#000',
-    backgroundOpacity: '1',
-    color: '#FFF',
-    fontFamily: 'proportionalSansSerif',
-    textOpacity: '1',
-    windowColor: '#000',
-    windowOpacity: '0'
+  backgroundColor: '#000',
+  backgroundOpacity: '1',
+  color: '#FFF',
+  fontFamily: 'proportionalSansSerif',
+  textOpacity: '1',
+  windowColor: '#000',
+  windowOpacity: '0'
 };
 
-q.module('Text Track Settings', {
+QUnit.module('Text Track Settings', {
   beforeEach() {
     window.localStorage.clear();
   }
 });
 
-test('should update settings', function() {
-  let player = TestHelpers.makePlayer({
+QUnit.test('should update settings', function() {
+  const player = TestHelpers.makePlayer({
     tracks,
     persistTextTrackSettings: true
   });
@@ -43,26 +44,49 @@ test('should update settings', function() {
   };
 
   player.textTrackSettings.setValues(newSettings);
-  deepEqual(player.textTrackSettings.getValues(), newSettings, 'values are updated');
+  QUnit.deepEqual(player.textTrackSettings.getValues(),
+                  newSettings,
+                  'values are updated');
 
-  equal(player.$('.vjs-fg-color > select').selectedIndex, 2, 'fg-color is set to new value');
-  equal(player.$('.vjs-bg-color > select').selectedIndex, 1, 'bg-color is set to new value');
-  equal(player.$('.window-color > select').selectedIndex, 1, 'window-color is set to new value');
-  equal(player.$('.vjs-text-opacity > select').selectedIndex, 1, 'text-opacity is set to new value');
-  equal(player.$('.vjs-bg-opacity > select').selectedIndex, 1, 'bg-opacity is set to new value');
-  equal(player.$('.vjs-window-opacity > select').selectedIndex, 1, 'window-opacity is set to new value');
-  equal(player.$('.vjs-edge-style select').selectedIndex, 1, 'edge-style is set to new value');
-  equal(player.$('.vjs-font-family select').selectedIndex, 3, 'font-family is set to new value');
-  equal(player.$('.vjs-font-percent select').selectedIndex, 3, 'font-percent is set to new value');
+  QUnit.equal(player.$('.vjs-fg-color > select').selectedIndex,
+              2,
+              'fg-color is set to new value');
+  QUnit.equal(player.$('.vjs-bg-color > select').selectedIndex,
+              1,
+              'bg-color is set to new value');
+  QUnit.equal(player.$('.window-color > select').selectedIndex,
+              1,
+              'window-color is set to new value');
+  QUnit.equal(player.$('.vjs-text-opacity > select').selectedIndex,
+              1,
+              'text-opacity is set to new value');
+  QUnit.equal(player.$('.vjs-bg-opacity > select').selectedIndex,
+              1,
+              'bg-opacity is set to new value');
+  QUnit.equal(player.$('.vjs-window-opacity > select').selectedIndex,
+              1,
+              'window-opacity is set to new value');
+  QUnit.equal(player.$('.vjs-edge-style select').selectedIndex,
+              1,
+              'edge-style is set to new value');
+  QUnit.equal(player.$('.vjs-font-family select').selectedIndex,
+              3,
+              'font-family is set to new value');
+  QUnit.equal(player.$('.vjs-font-percent select').selectedIndex,
+              3,
+              'font-percent is set to new value');
 
   Events.trigger(player.$('.vjs-done-button'), 'click');
-  deepEqual(safeParseTuple(window.localStorage.getItem('vjs-text-track-settings'))[1], newSettings, 'values are saved');
+  QUnit.deepEqual(safeParseTuple(
+                    window.localStorage.getItem('vjs-text-track-settings'))[1],
+                  newSettings,
+                  'values are saved');
 
   player.dispose();
 });
 
-test('should restore default settings', function() {
-  let player = TestHelpers.makePlayer({
+QUnit.test('should restore default settings', function() {
+  const player = TestHelpers.makePlayer({
     tracks,
     persistTextTrackSettings: true
   });
@@ -81,73 +105,96 @@ test('should restore default settings', function() {
   Events.trigger(player.$('.vjs-default-button'), 'click');
   Events.trigger(player.$('.vjs-done-button'), 'click');
 
-  deepEqual(player.textTrackSettings.getValues(), defaultSettings, 'values are defaulted');
-  // MikeA: need to figure out how to modify saveSettings to factor in defaults are no longer null
- // deepEqual(window.localStorage.getItem('vjs-text-track-settings'), defaultSettings, 'values are saved');
+  QUnit.deepEqual(player.textTrackSettings.getValues(),
+                  defaultSettings,
+                  'values are defaulted');
+  // TODO:
+  // MikeA: need to figure out how to modify saveSettings
+  // to factor in defaults are no longer null
+  // QUnit.deepEqual(window.localStorage.getItem('vjs-text-track-settings'),
+  //                 defaultSettings,
+  //                 'values are saved');
 
-  equal(player.$('.vjs-fg-color > select').selectedIndex, 0, 'fg-color is set to default value');
-  equal(player.$('.vjs-bg-color > select').selectedIndex, 0, 'bg-color is set to default value');
-  equal(player.$('.window-color > select').selectedIndex, 0, 'window-color is set to default value');
-  equal(player.$('.vjs-text-opacity > select').selectedIndex, 0, 'text-opacity is set to default value');
-  equal(player.$('.vjs-bg-opacity > select').selectedIndex, 0, 'bg-opacity is set to default value');
-  equal(player.$('.vjs-window-opacity > select').selectedIndex, 0, 'window-opacity is set to default value');
-  equal(player.$('.vjs-edge-style select').selectedIndex, 0, 'edge-style is set to default value');
-  equal(player.$('.vjs-font-family select').selectedIndex, 0, 'font-family is set to default value');
-  equal(player.$('.vjs-font-percent select').selectedIndex, 2, 'font-percent is set to default value');
+  QUnit.equal(player.$('.vjs-fg-color > select').selectedIndex,
+              0,
+              'fg-color is set to default value');
+  QUnit.equal(player.$('.vjs-bg-color > select').selectedIndex,
+              0,
+              'bg-color is set to default value');
+  QUnit.equal(player.$('.window-color > select').selectedIndex,
+              0,
+              'window-color is set to default value');
+  QUnit.equal(player.$('.vjs-text-opacity > select').selectedIndex,
+              0,
+              'text-opacity is set to default value');
+  QUnit.equal(player.$('.vjs-bg-opacity > select').selectedIndex,
+              0,
+              'bg-opacity is set to default value');
+  QUnit.equal(player.$('.vjs-window-opacity > select').selectedIndex,
+              0,
+              'window-opacity is set to default value');
+  QUnit.equal(player.$('.vjs-edge-style select').selectedIndex,
+              0,
+              'edge-style is set to default value');
+  QUnit.equal(player.$('.vjs-font-family select').selectedIndex,
+              0,
+              'font-family is set to default value');
+  QUnit.equal(player.$('.vjs-font-percent select').selectedIndex,
+              2,
+              'font-percent is set to default value');
 
   player.dispose();
 });
 
-test('should open on click', function() {
-  let player = TestHelpers.makePlayer({
+QUnit.test('should open on click', function() {
+  const player = TestHelpers.makePlayer({
     tracks
   });
 
   Events.trigger(player.$('.vjs-texttrack-settings'), 'click');
-  ok(!player.textTrackSettings.hasClass('vjs-hidden'), 'settings open');
+  QUnit.ok(!player.textTrackSettings.hasClass('vjs-hidden'), 'settings open');
 
   player.dispose();
 });
 
-test('should close on done click', function() {
-  let player = TestHelpers.makePlayer({
+QUnit.test('should close on done click', function() {
+  const player = TestHelpers.makePlayer({
     tracks
   });
 
   Events.trigger(player.$('.vjs-texttrack-settings'), 'click');
   Events.trigger(player.$('.vjs-done-button'), 'click');
-  ok(player.textTrackSettings.hasClass('vjs-hidden'), 'settings closed');
+  QUnit.ok(player.textTrackSettings.hasClass('vjs-hidden'), 'settings closed');
 
   player.dispose();
 });
 
-test('if persist option is set, restore settings on init', function() {
-  let player;
-  let oldRestoreSettings = TextTrackSettings.prototype.restoreSettings;
+QUnit.test('if persist option is set, restore settings on init', function() {
+  const oldRestoreSettings = TextTrackSettings.prototype.restoreSettings;
   let restore = 0;
 
   TextTrackSettings.prototype.restoreSettings = function() {
     restore++;
   };
 
-  player = TestHelpers.makePlayer({
+  const player = TestHelpers.makePlayer({
     tracks,
     persistTextTrackSettings: true
   });
 
-  equal(restore, 1, 'restore was called');
+  QUnit.equal(restore, 1, 'restore was called');
 
   TextTrackSettings.prototype.restoreSettings = oldRestoreSettings;
 
   player.dispose();
 });
 
-test('if persist option is set, save settings when "done"', function() {
-  let player = TestHelpers.makePlayer({
+QUnit.test('if persist option is set, save settings when "done"', function() {
+  const player = TestHelpers.makePlayer({
     tracks,
     persistTextTrackSettings: true
   });
-  let oldSaveSettings = TextTrackSettings.prototype.saveSettings;
+  const oldSaveSettings = TextTrackSettings.prototype.saveSettings;
   let save = 0;
 
   TextTrackSettings.prototype.saveSettings = function() {
@@ -156,17 +203,16 @@ test('if persist option is set, save settings when "done"', function() {
 
   Events.trigger(player.$('.vjs-done-button'), 'click');
 
-  equal(save, 1, 'save was called');
+  QUnit.equal(save, 1, 'save was called');
 
   TextTrackSettings.prototype.saveSettings = oldSaveSettings;
 
   player.dispose();
 });
 
-test('do not try to restore or save settings if persist option is not set', function() {
-  let player;
-  let oldRestoreSettings = TextTrackSettings.prototype.restoreSettings;
-  let oldSaveSettings = TextTrackSettings.prototype.saveSettings;
+QUnit.test('do not try to restore or save settings if persist option is not set', function() {
+  const oldRestoreSettings = TextTrackSettings.prototype.restoreSettings;
+  const oldSaveSettings = TextTrackSettings.prototype.saveSettings;
   let save = 0;
   let restore = 0;
 
@@ -177,17 +223,17 @@ test('do not try to restore or save settings if persist option is not set', func
     save++;
   };
 
-  player = TestHelpers.makePlayer({
+  const player = TestHelpers.makePlayer({
     tracks,
     persistTextTrackSettings: false
   });
 
-  equal(restore, 0, 'restore was not called');
+  QUnit.equal(restore, 0, 'restore was not called');
 
   Events.trigger(player.$('.vjs-done-button'), 'click');
 
   // saveSettings is called but does nothing
-  equal(save, 1, 'save was not called');
+  QUnit.equal(save, 1, 'save was not called');
 
   TextTrackSettings.prototype.saveSettings = oldSaveSettings;
   TextTrackSettings.prototype.restoreSettings = oldRestoreSettings;
@@ -195,8 +241,7 @@ test('do not try to restore or save settings if persist option is not set', func
   player.dispose();
 });
 
-test('should restore saved settings', function() {
-  let player;
+QUnit.test('should restore saved settings', function() {
   const newSettings = {
     backgroundOpacity: '0.5',
     textOpacity: '0.5',
@@ -211,18 +256,17 @@ test('should restore saved settings', function() {
 
   window.localStorage.setItem('vjs-text-track-settings', JSON.stringify(newSettings));
 
-  player = TestHelpers.makePlayer({
+  const player = TestHelpers.makePlayer({
     tracks,
     persistTextTrackSettings: true
   });
 
-  deepEqual(player.textTrackSettings.getValues(), newSettings);
+  QUnit.deepEqual(player.textTrackSettings.getValues(), newSettings);
 
   player.dispose();
 });
 
-test('should not restore saved settings', function() {
-  let player;
+QUnit.test('should not restore saved settings', function() {
   const newSettings = {
     backgroundOpacity: '0.5',
     textOpacity: '0.5',
@@ -237,12 +281,12 @@ test('should not restore saved settings', function() {
 
   window.localStorage.setItem('vjs-text-track-settings', JSON.stringify(newSettings));
 
-  player = TestHelpers.makePlayer({
+  const player = TestHelpers.makePlayer({
     tracks,
     persistTextTrackSettings: false
   });
 
-  deepEqual(player.textTrackSettings.getValues(), defaultSettings);
+  QUnit.deepEqual(player.textTrackSettings.getValues(), defaultSettings);
 
   player.dispose();
 });