shaka-player 4.4.2 → 4.5.0

package/test/codec_switching/codec_switching_integration.js

@@ -0,0 +1,181 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+describe('Codec Switching', () => {
+  /** @type {!HTMLVideoElement} */
+  let video;
+  /** @type {shaka.Player} */
+  let player;
+  /** @type {!shaka.util.EventManager} */
+  let eventManager;
+
+  let compiledShaka;
+
+  /** @type {!shaka.test.Waiter} */
+  let waiter;
+
+  beforeAll(async () => {
+    video = shaka.test.UiUtils.createVideoElement();
+    document.body.appendChild(video);
+    compiledShaka =
+          await shaka.test.Loader.loadShaka(getClientArg('uncompiled'));
+  });
+
+  beforeEach(async () => {
+    await shaka.test.TestScheme.createManifests(compiledShaka, '_compiled');
+    player = new compiledShaka.Player(video);
+
+    // Disable stall detection, which can interfere with playback tests.
+    player.configure('streaming.stallEnabled', false);
+
+    eventManager = new shaka.util.EventManager();
+    waiter = new shaka.test.Waiter(eventManager);
+    waiter.setPlayer(player);
+  });
+
+  afterEach(async () => {
+    eventManager.release();
+    await player.destroy();
+  });
+
+  afterAll(() => {
+    document.body.removeChild(video);
+  });
+
+  describe('for audio and only-audio content', () => {
+    it('can switch codecs RELOAD', async () => {
+      if (!MediaSource.isTypeSupported('audio/webm; codecs="opus"')) {
+        pending('Codec OPUS in WEBM is not supported by the platform.');
+      }
+      const preferredAudioLanguage = 'en';
+      player.configure({preferredAudioLanguage: preferredAudioLanguage});
+      player.configure('manifest.disableVideo', true);
+      player.configure('streaming.mediaSource.codecSwitchingStrategy',
+          shaka.config.CodecSwitchingStrategy.RELOAD);
+
+      await player.load('/base/test/test/assets/dash-multi-codec/dash.mpd', 9);
+      await video.play();
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      expect(player.isLive()).toBe(false);
+
+      let variants = player.getVariantTracks();
+
+      expect(variants.length).toBe(2);
+      expect(variants.find((v) => !!v.active).language).toBe('en');
+
+      player.selectAudioLanguage('es');
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 10, 45);
+
+      variants = player.getVariantTracks();
+
+      expect(variants.find((v) => !!v.active).language).toBe('es');
+
+      await player.unload();
+    });
+
+    it('can switch codecs SMOOTH', async () => {
+      if (!shaka.util.Platform.supportsSmoothCodecSwitching()) {
+        pending('Mediasource.ChangeType is not considered ' +
+          'reliable on this device');
+      }
+      if (!MediaSource.isTypeSupported('audio/webm; codecs="opus"')) {
+        pending('Codec OPUS in WEBM is not supported by the platform.');
+      }
+      const preferredAudioLanguage = 'en';
+      player.configure({preferredAudioLanguage: preferredAudioLanguage});
+      player.configure('manifest.disableVideo', true);
+      player.configure('streaming.mediaSource.codecSwitchingStrategy',
+          shaka.config.CodecSwitchingStrategy.SMOOTH);
+
+      await player.load('/base/test/test/assets/dash-multi-codec/dash.mpd', 9);
+      await video.play();
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      expect(player.isLive()).toBe(false);
+
+      let variants = player.getVariantTracks();
+
+      expect(variants.length).toBe(2);
+      expect(variants.find((v) => !!v.active).language).toBe('en');
+
+      player.selectAudioLanguage('es');
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 10, 45);
+
+      variants = player.getVariantTracks();
+
+      expect(variants.find((v) => !!v.active).language).toBe('es');
+
+      await player.unload();
+    });
+  });
+
+  describe('for audio', () => {
+    it('can switch codecs RELOAD', async () => {
+      if (!MediaSource.isTypeSupported('audio/webm; codecs="opus"')) {
+        pending('Codec OPUS in WEBM is not supported by the platform.');
+      }
+      const preferredAudioLanguage = 'en';
+      player.configure({preferredAudioLanguage: preferredAudioLanguage});
+      player.configure('streaming.mediaSource.codecSwitchingStrategy',
+          shaka.config.CodecSwitchingStrategy.RELOAD);
+
+      await player.load('/base/test/test/assets/dash-multi-codec/dash.mpd', 9);
+      await video.play();
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      expect(player.isLive()).toBe(false);
+
+      let variants = player.getVariantTracks();
+
+      expect(variants.length).toBe(2);
+      expect(variants.find((v) => !!v.active).language).toBe('en');
+
+      player.selectAudioLanguage('es');
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 10, 45);
+
+      variants = player.getVariantTracks();
+
+      expect(variants.find((v) => !!v.active).language).toBe('es');
+
+      await player.unload();
+    });
+
+    it('can switch codecs SMOOTH', async () => {
+      if (!shaka.util.Platform.supportsSmoothCodecSwitching()) {
+        pending('Mediasource.ChangeType is not considered ' +
+          'reliable on this device');
+      }
+      if (!MediaSource.isTypeSupported('audio/webm; codecs="opus"')) {
+        pending('Codec OPUS in WEBM is not supported by the platform.');
+      }
+      const preferredAudioLanguage = 'en';
+      player.configure({preferredAudioLanguage: preferredAudioLanguage});
+      player.configure('streaming.mediaSource.codecSwitchingStrategy',
+          shaka.config.CodecSwitchingStrategy.SMOOTH);
+
+      await player.load('/base/test/test/assets/dash-multi-codec/dash.mpd', 9);
+      await video.play();
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      expect(player.isLive()).toBe(false);
+
+      let variants = player.getVariantTracks();
+
+      expect(variants.length).toBe(2);
+      expect(variants.find((v) => !!v.active).language).toBe('en');
+
+      player.selectAudioLanguage('es');
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 10, 45);
+
+      variants = player.getVariantTracks();
+
+      expect(variants.find((v) => !!v.active).language).toBe('es');
+
+      await player.unload();
+    });
+  });
+});

package/test/dash/dash_parser_content_protection_unit.js

@@ -45,6 +45,8 @@ describe('DashParser ContentProtection', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
 
     const actual = await dashParser.start(

package/test/dash/dash_parser_integration.js

@@ -0,0 +1,73 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+describe('DashParser', () => {
+  const Util = shaka.test.Util;
+
+  /** @type {!jasmine.Spy} */
+  let onErrorSpy;
+
+  /** @type {!HTMLVideoElement} */
+  let video;
+  /** @type {shaka.Player} */
+  let player;
+  /** @type {!shaka.util.EventManager} */
+  let eventManager;
+
+  let compiledShaka;
+
+  /** @type {!shaka.test.Waiter} */
+  let waiter;
+
+  beforeAll(async () => {
+    video = shaka.test.UiUtils.createVideoElement();
+    document.body.appendChild(video);
+    compiledShaka =
+        await shaka.test.Loader.loadShaka(getClientArg('uncompiled'));
+  });
+
+  beforeEach(async () => {
+    await shaka.test.TestScheme.createManifests(compiledShaka, '_compiled');
+    player = new compiledShaka.Player(video);
+
+    // Disable stall detection, which can interfere with playback tests.
+    player.configure('streaming.stallEnabled', false);
+
+    // Grab event manager from the uncompiled library:
+    eventManager = new shaka.util.EventManager();
+    waiter = new shaka.test.Waiter(eventManager);
+    waiter.setPlayer(player);
+
+    onErrorSpy = jasmine.createSpy('onError');
+    onErrorSpy.and.callFake((event) => fail(event.detail));
+    eventManager.listen(player, 'error', Util.spyFunc(onErrorSpy));
+  });
+
+  afterEach(async () => {
+    eventManager.release();
+    await player.destroy();
+  });
+
+  afterAll(() => {
+    document.body.removeChild(video);
+  });
+
+  it('supports AES-128 streaming', async () => {
+    await player.load('/base/test/test/assets/dash-aes-128/dash.mpd');
+    await video.play();
+    expect(player.isLive()).toBe(false);
+
+    // Wait for the video to start playback.  If it takes longer than 10
+    // seconds, fail the test.
+    await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+    // Play for 10 seconds, but stop early if the video ends.  If it takes
+    // longer than 30 seconds, fail the test.
+    await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 10, 30);
+
+    await player.unload();
+  });
+});

package/test/dash/dash_parser_live_unit.js

@@ -36,6 +36,8 @@ describe('DashParser Live', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
   });
 

package/test/dash/dash_parser_manifest_unit.js

@@ -54,9 +54,16 @@ describe('DashParser Manifest', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
   });
 
+  afterEach(() => {
+    // Dash parser stop is synchronous.
+    parser.stop();
+  });
+
   /**
    * Makes a series of tests for the given manifest type.
    *
@@ -1175,6 +1182,46 @@ describe('DashParser Manifest', () => {
     expect(trickModeVideo).toBe(null);
   });
 
+  it('populates groupId if configuration enabled', async () => {
+    const manifestText = [
+      '<MPD minBufferTime="PT75S">',
+      '  <Period id="1" duration="PT30S">',
+      '    <AdaptationSet id="1" contentType="text">',
+      '      <Representation id="text-en" mimeType="text/webvtt">',
+      '        <BaseURL>t-en.vtt</BaseURL>',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '    <AdaptationSet id="2" mimeType="video/mp4">',
+      '      <Representation id="video-sd" width="640" height="480">',
+      '        <BaseURL>v-sd.mp4</BaseURL>',
+      '        <SegmentBase indexRange="100-200" />',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '    <AdaptationSet id="3" mimeType="audio/mp4">',
+      '      <Representation id="audio-en">',
+      '        <BaseURL>a-en.mp4</BaseURL>',
+      '        <SegmentBase indexRange="100-200" />',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '  </Period>',
+      '</MPD>',
+    ].join('\n');
+
+    fakeNetEngine.setResponseText('dummy://foo', manifestText);
+
+    const config = shaka.util.PlayerConfiguration.createDefault().manifest;
+    config.dash.enableAudioGroups = true;
+    parser.configure(config);
+
+    /** @type {shaka.extern.Manifest} */
+    const manifest = await parser.start('dummy://foo', playerInterface);
+
+
+    expect(manifest.variants.length).toBe(1);
+    const variant = manifest.variants[0];
+    expect(variant.audio.groupId).toBe('3');
+  });
+
   it('sets contentType to text for embedded text mime types', async () => {
     // One MIME type for embedded TTML, one for embedded WebVTT.
     // One MIME type specified on AdaptationSet, on one Representation.

package/test/dash/dash_parser_segment_base_unit.js

@@ -40,9 +40,16 @@ describe('DashParser SegmentBase', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
   });
 
+  afterEach(() => {
+    // Dash parser stop is synchronous.
+    parser.stop();
+  });
+
   it('requests init data for WebM', async () => {
     const source = [
       '<MPD mediaPresentationDuration="PT75S">',

package/test/dash/dash_parser_segment_list_unit.js

@@ -350,25 +350,31 @@ describe('DashParser SegmentList', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
-    const manifest = await dashParser.start('dummy://foo', playerInterface);
-    const stream = manifest.variants[0].video;
-    await stream.createSegmentIndex();
-    goog.asserts.assert(stream.segmentIndex, 'Expected index to be created');
+    try {
+      const manifest = await dashParser.start('dummy://foo', playerInterface);
+      const stream = manifest.variants[0].video;
+      await stream.createSegmentIndex();
+      goog.asserts.assert(stream.segmentIndex, 'Expected index to be created');
 
-    // Don't use Dash.testSegmentIndex since it uses SegmentIndex.find, which
-    // doesn't reproduce this issue.  We want to use Array.from which uses the
-    // iterator.
-    const expected = [
-      ManifestParser.makeReference('s1.mp4', 0, 10, baseUri),
-      ManifestParser.makeReference('s2.mp4', 10, 20, baseUri),
-      ManifestParser.makeReference('s3.mp4', 20, 30, baseUri),
+      // Don't use Dash.testSegmentIndex since it uses SegmentIndex.find, which
+      // doesn't reproduce this issue.  We want to use Array.from which uses
+      // the iterator.
+      const expected = [
+        ManifestParser.makeReference('s1.mp4', 0, 10, baseUri),
+        ManifestParser.makeReference('s2.mp4', 10, 20, baseUri),
+        ManifestParser.makeReference('s3.mp4', 20, 30, baseUri),
 
-      ManifestParser.makeReference('s3.mp4', 30, 40, baseUri),
-      ManifestParser.makeReference('s4.mp4', 40, 50, baseUri),
-      ManifestParser.makeReference('s5.mp4', 50, 60, baseUri),
-    ];
-    const actual = Array.from(stream.segmentIndex);
-    expect(actual).toEqual(expected);
+        ManifestParser.makeReference('s3.mp4', 30, 40, baseUri),
+        ManifestParser.makeReference('s4.mp4', 40, 50, baseUri),
+        ManifestParser.makeReference('s5.mp4', 50, 60, baseUri),
+      ];
+      const actual = Array.from(stream.segmentIndex);
+      expect(actual).toEqual(expected);
+    } finally {
+      dashParser.stop();
+    }
   });
 });

package/test/dash/dash_parser_segment_template_unit.js

@@ -49,9 +49,16 @@ describe('DashParser SegmentTemplate', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
   });
 
+  afterEach(() => {
+    // Dash parser stop is synchronous.
+    parser.stop();
+  });
+
   shaka.test.Dash.makeTimelineTests(
       'SegmentTemplate', 'media="s$Number$.mp4"', []);
 
@@ -670,6 +677,48 @@ describe('DashParser SegmentTemplate', () => {
         expect(pos).toBe(1);
       });
 
+      it('finds correct position in multiperiod content', async () => {
+        const source = [
+          '<MPD type="static" availabilityStartTime="1970-01-01T00:00:00Z">',
+          '  <Period duration="PT30S">',
+          '    <AdaptationSet mimeType="video/mp4">',
+          '      <Representation bandwidth="500">',
+          '        <BaseURL>http://example.com</BaseURL>',
+          '          <SegmentTemplate startNumber="0"',
+          '            media="$Number$-$Time$-$Bandwidth$.mp4">',
+          '            <SegmentTimeline>',
+          '              <S t="0" d="5" r="6" />',
+          '            </SegmentTimeline>',
+          '          </SegmentTemplate>',
+          '      </Representation>',
+          '    </AdaptationSet>',
+          '  </Period>',
+          '  <Period duration="PT30S">',
+          '    <AdaptationSet mimeType="video/mp4">',
+          '      <Representation bandwidth="500">',
+          '        <BaseURL>http://example.com</BaseURL>',
+          '          <SegmentTemplate startNumber="6"',
+          '            media="$Number$-$Time$-$Bandwidth$.mp4">',
+          '            <SegmentTimeline>',
+          '              <S t="0" d="5" r="6" />',
+          '            </SegmentTimeline>',
+          '          </SegmentTemplate>',
+          '      </Representation>',
+          '    </AdaptationSet>',
+          '  </Period>',
+          '</MPD>',
+        ].join('\n');
+
+        fakeNetEngine.setResponseText('dummy://foo', source);
+        const manifest = await parser.start('dummy://foo', playerInterface);
+        const stream = manifest.variants[0].video;
+        await stream.createSegmentIndex();
+
+        // simulate a seek into the second period
+        const segmentIterator = stream.segmentIndex.getIteratorForTime(42);
+        const ref = segmentIterator.next().value;
+        expect(ref.startTime).toBe(40);
+      });
 
       it('returns null if time === last end time', async () => {
         const info = makeTemplateInfo(makeRanges(0, 2.0, 2));

package/test/demo/demo_unit.js

@@ -33,22 +33,6 @@ describe('Demo', () => {
     await shakaDemoMain.cleanup();
   });
 
-  it('has all messages defined', async () => {
-    const englishBuffer =
-        await shaka.test.Util.fetch('/base/demo/locales/en.json');
-    const englishMessages = JSON.parse(shaka.util.StringUtils.fromUTF8(
-        englishBuffer));
-    const sourceBuffer =
-        await shaka.test.Util.fetch('/base/demo/locales/source.json');
-    const sourceMessages = JSON.parse(shaka.util.StringUtils.fromUTF8(
-        sourceBuffer));
-
-    for (const id of Object.values(shakaDemo.MessageIds)) {
-      expect(englishMessages[id]).withContext(`id=${id}, English`).toBeTruthy();
-      expect(sourceMessages[id]).withContext(`id=${id}, source`).toBeTruthy();
-    }
-  });
-
   describe('config', () => {
     it('does not have entries for invalid config options', () => {
       // We determine whether a config option has been made or not by looking at

package/test/hls/hls_live_unit.js

@@ -77,6 +77,8 @@ describe('HlsParser live', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
 
     parser = new shaka.hls.HlsParser();
@@ -540,10 +542,43 @@ describe('HlsParser live', () => {
 
     it('sets 3 times target duration as presentation delay if not configured',
         async () => {
+          const media = [
+            '#EXTM3U\n',
+            '#EXT-X-TARGETDURATION:5\n',
+            '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
+            '#EXT-X-MEDIA-SEQUENCE:0\n',
+            '#EXTINF:2,\n',
+            'main.mp4\n',
+            '#EXTINF:2,\n',
+            'main.mp4\n',
+            '#EXTINF:2,\n',
+            'main.mp4\n',
+            '#EXTINF:2,\n',
+            'main.mp4\n',
+            '#EXTINF:2,\n',
+            'main.mp4\n',
+            '#EXTINF:2,\n',
+            'main.mp4\n',
+          ].join('');
           const manifest = await testInitialManifest(master, media);
           expect(manifest.presentationTimeline.getDelay()).toBe(15);
         });
 
+    it('sets 1 times target duration as presentation delay if there are not enough segments', async () => { // eslint-disable-line max-len
+      const media = [
+        '#EXTM3U\n',
+        '#EXT-X-TARGETDURATION:5\n',
+        '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
+        '#EXT-X-MEDIA-SEQUENCE:0\n',
+        '#EXTINF:2,\n',
+        'main.mp4\n',
+        '#EXTINF:2,\n',
+        'main.mp4\n',
+      ].join('');
+      const manifest = await testInitialManifest(master, media);
+      expect(manifest.presentationTimeline.getDelay()).toBe(5);
+    });
+
     it('sets presentation delay if defined', async () => {
       const media = [
         '#EXTM3U\n',

package/test/hls/hls_parser_unit.js

@@ -90,6 +90,8 @@ describe('HlsParser', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: shaka.test.Util.spyFunc(newDrmInfoSpy),
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
 
     parser = new shaka.hls.HlsParser();
@@ -1136,63 +1138,6 @@ describe('HlsParser', () => {
     expect(references[6].discontinuitySequence).toBe(3);
   });
 
-  it('sets reference timetampOffset based on discontinuity start time',
-      async () => {
-        const master = [
-          '#EXTM3U\n',
-          '#EXT-X-STREAM-INF:BANDWIDTH=2000000,CODECS="avc1"\n',
-          'video\n',
-        ].join('');
-
-        const media = [
-          '#EXTM3U\n',
-          '#EXT-X-VERSION:3\n',
-          '#EXT-X-TARGETDURATION:5\n',
-          '#EXT-X-MEDIA-SEQUENCE:0\n',
-          '#EXTINF:3,\n',
-          'clip0-video-0.ts\n',
-          '#EXTINF:1,\n',
-          'clip0-video-1.ts\n',
-          '#EXT-X-DISCONTINUITY\n',
-          '#EXTINF:2,\n',
-          'clip1-video-1.ts\n',
-          '#EXTINF:3,\n',
-          'clip1-video-2.ts\n',
-          '#EXT-X-DISCONTINUITY\n',
-          '#EXTINF:1,\n',
-          'media-clip2-video-0.ts\n',
-          '#EXTINF:1,\n',
-          'media-clip2-video-1.ts\n',
-          '#EXT-X-DISCONTINUITY\n',
-          '#EXTINF:4,\n',
-          'media-clip3-video-1.ts\n',
-          '#EXT-X-ENDLIST\n',
-        ].join('');
-
-        fakeNetEngine
-            .setResponseText('test:/master', master)
-            .setResponseText('test:/video', media);
-
-        const manifest = await parser.start('test:/master', playerInterface);
-        await manifest.variants[0].video.createSegmentIndex();
-
-        const segmentIndex = manifest.variants[0].video.segmentIndex;
-        const references = [];
-
-        for (let i = 0; i < 7; i++) {
-          references.push(segmentIndex.get(i));
-        }
-
-        expect(references[0].timestampOffset).toBe(0);
-        expect(references[1].timestampOffset).toBe(0);
-        expect(references[2].timestampOffset).toBe(4);
-        expect(references[3].timestampOffset).toBe(4);
-        expect(references[4].timestampOffset).toBe(9);
-        expect(references[5].timestampOffset).toBe(9);
-        expect(references[6].timestampOffset).toBe(11);
-      },
-  );
-
   it('parses characteristics from audio tags', async () => {
     const master = [
       '#EXTM3U\n',
@@ -3181,9 +3126,11 @@ describe('HlsParser', () => {
         'Null segmentIndex!');
 
     const firstMp4Segment = mp4AesEncryptionVideo.segmentIndex.get(0);
-    expect(firstMp4Segment.hlsAes128Key).toBeDefined();
+    expect(firstMp4Segment.aes128Key).toBeDefined();
+    expect(firstMp4Segment.initSegmentReference.aes128Key).toBeDefined();
     const secondMp4Segment = mp4AesEncryptionVideo.segmentIndex.get(1);
-    expect(secondMp4Segment.hlsAes128Key).toBeNull();
+    expect(secondMp4Segment.aes128Key).toBeNull();
+    expect(secondMp4Segment.initSegmentReference.aes128Key).toBeDefined();
 
     const tsAesEncryptionVideo = actual.variants[2].video;
     await tsAesEncryptionVideo.createSegmentIndex();
@@ -3191,9 +3138,9 @@ describe('HlsParser', () => {
         'Null segmentIndex!');
 
     const firstTsSegment = tsAesEncryptionVideo.segmentIndex.get(0);
-    expect(firstTsSegment.hlsAes128Key).toBeDefined();
+    expect(firstTsSegment.aes128Key).toBeDefined();
     const secondTsSegment = tsAesEncryptionVideo.segmentIndex.get(1);
-    expect(secondTsSegment.hlsAes128Key).toBeNull();
+    expect(secondTsSegment.aes128Key).toBeNull();
   });
 
   it('fails on AES-128 if WebCrypto APIs are not available', async () => {