shaka-player 4.3.11 → 4.4.1

package/test/test/util/fake_networking_engine.js

@@ -174,9 +174,11 @@ shaka.test.FakeNetworkingEngine = class {
    *
    * @param {string} uri
    * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.RequestContext=} context
    */
-  expectRequest(uri, type) {
-    shaka.test.FakeNetworkingEngine.expectRequest(this.request, uri, type);
+  expectRequest(uri, type, context) {
+    shaka.test.FakeNetworkingEngine.expectRequest(
+        this.request, uri, type, context);
   }
 
   /**
@@ -184,9 +186,11 @@ shaka.test.FakeNetworkingEngine = class {
    *
    * @param {string} uri
    * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.RequestContext=} context
    */
-  expectNoRequest(uri, type) {
-    shaka.test.FakeNetworkingEngine.expectNoRequest(this.request, uri, type);
+  expectNoRequest(uri, type, context) {
+    shaka.test.FakeNetworkingEngine.expectNoRequest(
+        this.request, uri, type, context);
   }
 
   /**
@@ -195,10 +199,11 @@ shaka.test.FakeNetworkingEngine = class {
    * @param {string} uri
    * @param {number} startByte
    * @param {?number} endByte
+   * @param {boolean} isInit
    */
-  expectRangeRequest(uri, startByte, endByte) {
+  expectRangeRequest(uri, startByte, endByte, isInit) {
     shaka.test.FakeNetworkingEngine.expectRangeRequest(
-        this.request, uri, startByte, endByte);
+        this.request, uri, startByte, endByte, isInit);
   }
 
   /**
@@ -289,10 +294,18 @@ shaka.test.FakeNetworkingEngine = class {
    * @param {!Object} requestSpy
    * @param {string} uri
    * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.RequestContext=} context
    */
-  static expectRequest(requestSpy, uri, type) {
-    expect(requestSpy).toHaveBeenCalledWith(
-        type, jasmine.objectContaining({uris: [uri]}));
+  static expectRequest(requestSpy, uri, type, context) {
+    // Jasmine "toHaveBeenCalledWith" doesn't handle optional parameters well.
+    if (context != undefined) {
+      expect(requestSpy).toHaveBeenCalledWith(
+          type, jasmine.objectContaining({uris: [uri]}),
+          jasmine.objectContaining({type: context.type}));
+    } else {
+      expect(requestSpy).toHaveBeenCalledWith(
+          type, jasmine.objectContaining({uris: [uri]}));
+    }
   }
 
   /**
@@ -301,10 +314,18 @@ shaka.test.FakeNetworkingEngine = class {
    * @param {!Object} requestSpy
    * @param {string} uri
    * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.RequestContext=} context
    */
-  static expectNoRequest(requestSpy, uri, type) {
-    expect(requestSpy).not.toHaveBeenCalledWith(
-        type, jasmine.objectContaining({uris: [uri]}));
+  static expectNoRequest(requestSpy, uri, type, context) {
+    // Jasmine "toHaveBeenCalledWith" doesn't handle optional parameters well.
+    if (context != undefined) {
+      expect(requestSpy).not.toHaveBeenCalledWith(
+          type, jasmine.objectContaining({uris: [uri]}),
+          jasmine.objectContaining({type: context.type}));
+    } else {
+      expect(requestSpy).not.toHaveBeenCalledWith(
+          type, jasmine.objectContaining({uris: [uri]}));
+    }
   }
 
   /**
@@ -314,8 +335,9 @@ shaka.test.FakeNetworkingEngine = class {
    * @param {string} uri
    * @param {number} startByte
    * @param {?number} endByte
+   * @param {boolean} isInit
    */
-  static expectRangeRequest(requestSpy, uri, startByte, endByte) {
+  static expectRangeRequest(requestSpy, uri, startByte, endByte, isInit) {
     const headers = {};
     if (startByte == 0 && endByte == null) {
       // No header required.
@@ -327,12 +349,17 @@ shaka.test.FakeNetworkingEngine = class {
       headers['Range'] = range;
     }
 
+    const type = isInit ?
+        shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT :
+        shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
+
     expect(requestSpy).toHaveBeenCalledWith(
         shaka.net.NetworkingEngine.RequestType.SEGMENT,
         jasmine.objectContaining({
           uris: [uri],
           headers: headers,
-        }));
+        }),
+        jasmine.objectContaining({type}));
   }
 };
 

package/test/test/util/fake_segment_prefetch.js

@@ -0,0 +1,81 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * A fake SegmentPrefetch class that is used for testing
+ * segment prefetching functionality.
+ *
+ * @final
+ * @struct
+ * @extends {shaka.media.SegmentPrefetch}
+ */
+shaka.test.FakeSegmentPrefetch = class {
+  constructor(stream, segmentData) {
+    /** @private {(Set.<!shaka.media.SegmentReference>)} */
+    this.requestedReferences_ = new Set();
+
+    /** @private {shaka.extern.Stream} */
+    this.streamObj_ = stream;
+
+    /**
+     * @private {!Object.<string, shaka.test.FakeMediaSourceEngine.SegmentData>}
+     */
+    this.segmentData_ = segmentData;
+  }
+
+  /** @override */
+  prefetchSegments(reference) {
+    if (!(reference instanceof shaka.media.SegmentReference)) {
+      return;
+    }
+    this.requestedReferences_.add(reference);
+  }
+
+  /** @override */
+  switchStream(stream) {
+    if (stream !== this.streamObj_) {
+      this.requestedReferences_.clear();
+    }
+  }
+
+  /** @override */
+  resetLimit(limit) {
+    this.clearAll();
+  }
+
+  /** @override */
+  clearAll() {
+    this.requestedReferences_.clear();
+  }
+
+  /** @override */
+  getPrefetchedSegment(reference) {
+    if (!(reference instanceof shaka.media.SegmentReference)) {
+      return null;
+    }
+    /**
+     * The unit tests assume a segment is already prefetched
+     * if it was ever passed to prefetchSegments() as param.
+     * Otherwise return null so the streaming engine being tested
+     * will do actual fetch.
+     */
+    if (this.requestedReferences_.has(reference)) {
+      const segmentData = this.segmentData_[this.streamObj_.type];
+      return new shaka.net.NetworkingEngine.PendingRequest(
+          Promise.resolve({
+            uri: reference.getUris()[0],
+            data: segmentData.segments[
+                segmentData.segmentStartTimes.indexOf(reference.startTime)
+            ],
+            headers: {},
+          }),
+          () => Promise.resolve(null),
+          new shaka.net.NetworkingEngine.NumBytesRemainingClass(),
+      );
+    }
+    return null;
+  }
+};

package/test/test/util/manifest_generator.js

@@ -97,6 +97,13 @@ shaka.test.ManifestGenerator.Manifest = class {
     this.minBufferTime = 0;
     /** @type {boolean} */
     this.sequenceMode = false;
+    /** @type {boolean} */
+    this.ignoreManifestTimestampsInSegmentsMode = false;
+    /** @type {string} */
+    this.type = 'UNKNOWN';
+    /** @type {?shaka.extern.ServiceDescription} */
+    this.serviceDescription = null;
+
 
     /** @type {shaka.extern.Manifest} */
     const foo = this;
@@ -263,6 +270,8 @@ shaka.test.ManifestGenerator.Variant = class {
     if (!isPartial) {
       /** @type {string} */
       this.language = 'und';
+      /** @type {string} */
+      this.label = '';
       /** @type {number} */
       this.bandwidth = 0;
       /** @type {number} */
@@ -316,7 +325,7 @@ shaka.test.ManifestGenerator.Variant = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const stream = new shaka.test.ManifestGenerator.Stream(
         this.manifest_, /* isPartial= */ false, id, ContentType.AUDIO,
-        this.language);
+        this.language, this.label);
     if (func) {
       func(stream);
     }
@@ -446,9 +455,10 @@ shaka.test.ManifestGenerator.Stream = class {
    * @param {boolean} isPartial
    * @param {?number} id
    * @param {shaka.util.ManifestParserUtils.ContentType} type
-   * @param {string=} lang
+   * @param {?string=} lang
+   * @param {string=} label
    */
-  constructor(manifest, isPartial, id, type, lang) {
+  constructor(manifest, isPartial, id, type, lang, label) {
     goog.asserts.assert(
         !manifest || !manifest.isIdUsed_(id),
         'Streams should have unique ids!');
@@ -516,9 +526,11 @@ shaka.test.ManifestGenerator.Stream = class {
       /** @type {!Set.<string>} */
       this.keyIds = new Set();
       /** @type {string} */
-      this.language = lang || 'und';
+      this.language = shaka.util.LanguageUtils.normalize(lang || 'und');
+      /** @type {?string} */
+      this.originalLanguage = lang || null;
       /** @type {?string} */
-      this.label = null;
+      this.label = label || null;
       /** @type {boolean} */
       this.primary = false;
       /** @type {?shaka.extern.Stream} */
@@ -541,6 +553,8 @@ shaka.test.ManifestGenerator.Stream = class {
       this.hdr = undefined;
       /** @type {(string|undefined)} */
       this.tilesLayout = undefined;
+      /** @type {?shaka.media.ManifestParser.AccessibilityPurpose} */
+      this.accessibilityPurpose;
       /** @type {boolean} */
       this.external = false;
     }

package/test/test/util/mss_parser_util.js

@@ -0,0 +1,115 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/** @summary Utilities for working with the MSS parser. */
+shaka.test.Mss = class {
+  /**
+   * Constructs and configures a very simple MSS parser.
+   * @return {!shaka.mss.MssParser}
+   */
+  static makeMssParser() {
+    const parser = new shaka.mss.MssParser();
+    const config = shaka.util.PlayerConfiguration.createDefault().manifest;
+    parser.configure(config);
+    return parser;
+  }
+
+  /**
+   * Tests the segment index produced by the MSS manifest parser.
+   *
+   * @param {string} manifestText
+   * @param {!Array.<shaka.media.SegmentReference>} references
+   * @return {!Promise}
+   */
+  static async testSegmentIndex(manifestText, references) {
+    const buffer = shaka.util.StringUtils.toUTF8(manifestText);
+    const mssParser = shaka.test.Mss.makeMssParser();
+
+    const networkingEngine = new shaka.test.FakeNetworkingEngine()
+        .setResponseValue('dummy://foo', buffer);
+
+    const playerInterface = {
+      networkingEngine: networkingEngine,
+      modifyManifestRequest: (request, manifestInfo) => {},
+      modifySegmentRequest: (request, segmentInfo) => {},
+      filter: () => {},
+      makeTextStreamsForClosedCaptions: (manifest) => {},
+      onTimelineRegionAdded: fail,
+      onEvent: fail,
+      onError: fail,
+      isLowLatencyMode: () => false,
+      isAutoLowLatencyMode: () => false,
+      enableLowLatencyMode: () => {},
+      updateDuration: () => {},
+      newDrmInfo: (stream) => {},
+    };
+    const manifest = await mssParser.start('dummy://foo', playerInterface);
+    const stream = manifest.variants[0].audio;
+    await stream.createSegmentIndex();
+
+    shaka.test.ManifestParser.verifySegmentIndex(stream, references);
+  }
+
+  /**
+   * Tests that the MSS manifest parser fails to parse the given manifest.
+   *
+   * @param {string} manifestText
+   * @param {!shaka.util.Error} expectedError
+   * @return {!Promise}
+   */
+  static async testFails(manifestText, expectedError) {
+    const manifestData = shaka.util.StringUtils.toUTF8(manifestText);
+    const mssParser = shaka.test.Mss.makeMssParser();
+
+    const networkingEngine = new shaka.test.FakeNetworkingEngine()
+        .setResponseValue('dummy://foo', manifestData);
+
+    const playerInterface = {
+      networkingEngine: networkingEngine,
+      modifyManifestRequest: (request, manifestInfo) => {},
+      modifySegmentRequest: (request, segmentInfo) => {},
+      filter: () => {},
+      makeTextStreamsForClosedCaptions: (manifest) => {},
+      onTimelineRegionAdded: fail,  // Should not have any EventStream elements.
+      onEvent: fail,
+      onError: fail,
+      isLowLatencyMode: () => false,
+      isAutoLowLatencyMode: () => false,
+      enableLowLatencyMode: () => {},
+      updateDuration: () => {},
+      newDrmInfo: (stream) => {},
+    };
+    const p = mssParser.start('dummy://foo', playerInterface);
+    await expectAsync(p).toBeRejectedWith(
+        shaka.test.Util.jasmineError(expectedError));
+  }
+
+  /**
+   * @param {shaka.extern.Manifest} manifest
+   * @return {!Promise.<shaka.media.SegmentReference>}
+   */
+  static async getFirstAudioSegmentReference(manifest) {
+    const variant = manifest.variants[0];
+    expect(variant).not.toBe(null);
+    if (!variant) {
+      return null;
+    }
+
+    const audio = variant.audio;
+    expect(audio).not.toBe(null);
+    if (!audio) {
+      return null;
+    }
+
+    await audio.createSegmentIndex();
+    const position = audio.segmentIndex.find(0);
+    goog.asserts.assert(position != null, 'Position should not be null!');
+
+    const reference = audio.segmentIndex.get(position);
+    goog.asserts.assert(reference != null, 'Reference should not be null!');
+    return reference;
+  }
+};

package/test/test/util/offline_utils.js

@@ -42,6 +42,7 @@ shaka.test.OfflineUtils = class {
       pixelAspectRatio: undefined,
       kind: undefined,
       language: '',
+      originalLanguage: null,
       label: null,
       width: null,
       height: null,

package/test/test/util/simple_fakes.js

@@ -503,17 +503,26 @@ shaka.test.FakeSegmentIndex = class {
   }
 };
 
-/** @extends {shaka.media.Transmuxer} */
+/** @implements {shaka.extern.Transmuxer} */
 shaka.test.FakeTransmuxer = class {
   constructor() {
+    const mp4MimeType = 'video/mp4; codecs="avc1.42E01E"';
+
     const output = {
       data: new Uint8Array(),
       captions: [],
     };
 
     /** @type {!jasmine.Spy} */
-    this.destroy =
-        jasmine.createSpy('destroy').and.returnValue(Promise.resolve());
+    this.destroy = jasmine.createSpy('destroy');
+
+    /** @type {!jasmine.Spy} */
+    this.isSupported =
+        jasmine.createSpy('isSupported').and.returnValue(true);
+
+    /** @type {!jasmine.Spy} */
+    this.convertCodecs =
+        jasmine.createSpy('convertCodecs').and.returnValue(mp4MimeType);
 
     /** @type {!jasmine.Spy} */
     this.transmux =

package/test/test/util/streaming_engine_util.js

@@ -28,12 +28,12 @@ shaka.test.StreamingEngineUtil = class {
   static createFakeNetworkingEngine(getInitSegment, getSegment, delays) {
     const netEngine = new shaka.test.FakeNetworkingEngine();
 
-    netEngine.request.and.callFake((requestType, request) => {
+    netEngine.request.and.callFake((requestType, request, context) => {
       expect(requestType).toBeTruthy();
       expect(request.uris.length).toBe(1);
 
       const parts = request.uris[0].split('_');
-      expect(parts.length).toBe(3);
+      expect(parts.length).toBeGreaterThanOrEqual(3);
 
       const periodIndex = Number(parts[0]);
       expect(periodIndex).not.toBeNaN();
@@ -284,6 +284,9 @@ shaka.test.StreamingEngineUtil = class {
       textStreams: [],
       imageStreams: [],
       sequenceMode: false,
+      ignoreManifestTimestampsInSegmentsMode: false,
+      type: 'UNKNOWN',
+      serviceDescription: null,
     };
 
     /** @type {shaka.extern.Variant} */
@@ -399,6 +402,7 @@ shaka.test.StreamingEngineUtil = class {
       type: ContentType.AUDIO,
       label: '',
       language: 'und',
+      originalLanguage: null,
       drmInfos: [],
       encrypted: false,
       keyIds: new Set(),
@@ -410,6 +414,7 @@ shaka.test.StreamingEngineUtil = class {
       roles: [],
       forced: false,
       spatialAudio: false,
+      accessibilityPurpose: null,
       external: false,
     };
   }
@@ -418,9 +423,10 @@ shaka.test.StreamingEngineUtil = class {
    * Creates a mock video Stream.
    *
    * @param {number} id
+   * @param {string=} mimeType
    * @return {shaka.extern.Stream}
    */
-  static createMockVideoStream(id) {
+  static createMockVideoStream(id, mimeType='video/mp4') {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const Util = shaka.test.Util;
 
@@ -429,7 +435,7 @@ shaka.test.StreamingEngineUtil = class {
       originalId: id.toString(),
       createSegmentIndex: Util.spyFunc(jasmine.createSpy('createSegmentIndex')),
       segmentIndex: null,
-      mimeType: 'video/mp4',
+      mimeType: mimeType,
       codecs: 'avc1.42c01e',
       bandwidth: 5000000,
       width: 600,
@@ -437,6 +443,7 @@ shaka.test.StreamingEngineUtil = class {
       type: ContentType.VIDEO,
       label: '',
       language: 'und',
+      originalLanguage: null,
       drmInfos: [],
       encrypted: false,
       keyIds: new Set(),
@@ -448,6 +455,7 @@ shaka.test.StreamingEngineUtil = class {
       roles: [],
       forced: false,
       spatialAudio: false,
+      accessibilityPurpose: null,
       external: false,
     };
   }
@@ -473,6 +481,7 @@ shaka.test.StreamingEngineUtil = class {
       type: ManifestParserUtils.ContentType.TEXT,
       label: '',
       language: 'und',
+      originalLanguage: null,
       drmInfos: [],
       encrypted: false,
       keyIds: new Set(),
@@ -484,6 +493,7 @@ shaka.test.StreamingEngineUtil = class {
       roles: [],
       forced: false,
       spatialAudio: false,
+      accessibilityPurpose: null,
       external: false,
     };
   }

package/test/test/util/ttml_utils.js

@@ -31,7 +31,7 @@ shaka.test.TtmlUtils = class {
 
     /**
      * @param {!Object} properties
-     * @return {!shaka.extern.Cue}
+     * @return {!shaka.text.Cue}
      */
     const makeContainer = (properties) => {
       const region = {
@@ -47,7 +47,7 @@ shaka.test.TtmlUtils = class {
         viewportAnchorUnits: shaka.text.CueRegion.units.PERCENTAGE,
         scroll: '',
       };
-      const containerCue = /** @type {!shaka.extern.Cue} */ ({
+      const containerCue = /** @type {!shaka.text.Cue} */ ({
         region,
         nestedCues: jasmine.any(Object),
         payload: '',

package/test/text/cue_integration.js

@@ -41,7 +41,7 @@ describe('Cue', () => {
   /**
    * @param {string} text
    * @param {!shaka.extern.TextParser.TimeContext} time
-   * @return {!Array.<!shaka.extern.Cue>}
+   * @return {!Array.<!shaka.text.Cue>}
    */
   function parseVtt(text, time) {
     const data =

package/test/text/srt_text_parser_unit.js

@@ -5,6 +5,8 @@
  */
 
 describe('SrtTextParser', () => {
+  const Cue = shaka.text.Cue;
+
   it('supports no cues', () => {
     verifyHelper([],
         '',
@@ -59,6 +61,82 @@ describe('SrtTextParser', () => {
         {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0});
   });
 
+  it('supports payload stylized', () => {
+    verifyHelper(
+        [
+          {
+            startTime: 10,
+            endTime: 20,
+            payload: '',
+            nestedCues: [
+              {
+                startTime: 10,
+                endTime: 20,
+                payload: 'Test',
+                fontWeight: Cue.fontWeight.BOLD,
+              },
+              {
+                startTime: 10,
+                endTime: 20,
+                payload: ' Unstyled',
+              },
+            ],
+          },
+          {
+            startTime: 20,
+            endTime: 30,
+            payload: '',
+            nestedCues: [
+              {
+                startTime: 20,
+                endTime: 30,
+                payload: 'Test2',
+                fontStyle: Cue.fontStyle.ITALIC,
+              },
+            ],
+          },
+          {
+            startTime: 30,
+            endTime: 40,
+            payload: '',
+            nestedCues: [
+              {
+                startTime: 30,
+                endTime: 40,
+                payload: 'Test3',
+                textDecoration: [Cue.textDecoration.UNDERLINE],
+              },
+            ],
+          },
+          {
+            startTime: 40,
+            endTime: 50,
+            payload: '',
+            nestedCues: [
+              {
+                startTime: 40,
+                endTime: 50,
+                payload: 'Test4',
+                color: 'red',
+              },
+            ],
+          },
+        ],
+        '1\n' +
+        '00:00:10,000 --> 00:00:20,000\n' +
+        '{b}Test{/b} Unstyled\n\n' +
+        '2\n' +
+        '00:00:20,000 --> 00:00:30,000\n' +
+        '{i}Test2{/i}\n\n' +
+        '3\n' +
+        '00:00:30,000 --> 00:00:40,000\n' +
+        '{u}Test3{/u}\n\n'+
+        '4\n' +
+        '00:00:40,000 --> 00:00:50,000\n' +
+        '<font color="red">Test4</font>',
+        {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0});
+  });
+
   /**
    * @param {!Array} cues
    * @param {string} text

package/test/text/text_engine_unit.js

@@ -66,14 +66,23 @@ describe('TextEngine', () => {
       expect(TextEngine.isTypeSupported(dummyMimeType)).toBe(false);
     });
 
-    it('reports support when it\'s closed captions',
-        () => {
-          // Both CEA-608 and CEA-708 is supported by our closed caption parser.
-          expect(TextEngine.isTypeSupported(
-              shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE)).toBe(true);
-          expect(TextEngine.isTypeSupported(
-              shaka.util.MimeUtils.CEA708_CLOSED_CAPTION_MIMETYPE)).toBe(true);
-        });
+    it('reports support for closed captions if decoder is installed', () => {
+      const originalFind = shaka.media.ClosedCaptionParser.findDecoder;
+      const mockFind = jasmine.createSpy('findDecoder').and.returnValue(null);
+      shaka.media.ClosedCaptionParser.findDecoder =
+          shaka.test.Util.spyFunc(mockFind);
+      // Both CEA-608 and CEA-708 is supported by our closed caption parser.
+      expect(TextEngine.isTypeSupported(
+          shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE)).toBe(false);
+      expect(TextEngine.isTypeSupported(
+          shaka.util.MimeUtils.CEA708_CLOSED_CAPTION_MIMETYPE)).toBe(false);
+
+      shaka.media.ClosedCaptionParser.findDecoder = originalFind;
+      expect(TextEngine.isTypeSupported(
+          shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE)).toBe(true);
+      expect(TextEngine.isTypeSupported(
+          shaka.util.MimeUtils.CEA708_CLOSED_CAPTION_MIMETYPE)).toBe(true);
+    });
   });
 
   describe('appendBuffer', () => {

package/test/text/ui_text_displayer_unit.js

@@ -81,10 +81,10 @@ describe('UITextDisplayer', () => {
     cue.direction = shaka.text.Cue.direction.HORIZONTAL_LEFT_TO_RIGHT;
     cue.fontSize = '10px';
     cue.fontWeight = shaka.text.Cue.fontWeight.NORMAL;
-    cue.fontStyle = 'normal';
+    cue.fontStyle = shaka.text.Cue.fontStyle.NORMAL;
     cue.lineHeight = '2';
     cue.nestedCues = [];
-    cue.textAlign = 'center';
+    cue.textAlign = shaka.text.Cue.textAlign.CENTER;
     cue.writingMode = shaka.text.Cue.writingMode.HORIZONTAL_TOP_TO_BOTTOM;
 
     textDisplayer.setTextVisibility(true);
@@ -126,13 +126,13 @@ describe('UITextDisplayer', () => {
     const cue = new shaka.text.Cue(0, 100, '');
     const nestedCue = new shaka.text.Cue(0, 100, 'Captain\'s log.');
     cue.nestedCues = [nestedCue];
-    nestedCue.textAlign = 'center';
+    nestedCue.textAlign = shaka.text.Cue.textAlign.CENTER;
     nestedCue.writingMode = shaka.text.Cue.writingMode.HORIZONTAL_TOP_TO_BOTTOM;
     nestedCue.color = 'green';
     nestedCue.backgroundColor = 'black';
     nestedCue.fontSize = '10px';
     nestedCue.fontWeight = shaka.text.Cue.fontWeight.NORMAL;
-    nestedCue.fontStyle = 'normal';
+    nestedCue.fontStyle = shaka.text.Cue.fontStyle.NORMAL;
     nestedCue.lineHeight = '2';
     nestedCue.nestedCues = [];