shaka-player 2.5.1 → 2.5.5

package/test/media/streaming_engine_unit.js

@@ -446,7 +446,10 @@ describe('StreamingEngine', function() {
       config.bufferBehind = Infinity;
     }
 
-    let playerInterface = {
+    goog.asserts.assert(
+        presentationTimeInSeconds != undefined,
+        'All tests should have defined an initial presentation time by now!');
+    const playerInterface = {
       getPresentationTime: () => presentationTimeInSeconds,
       getBandwidthEstimate: Util.spyFunc(getBandwidthEstimate),
       mediaSourceEngine: mediaSourceEngine,
@@ -985,6 +988,27 @@ describe('StreamingEngine', function() {
     expect(timeline.setDuration).not.toHaveBeenCalled();
   });
 
+  // https://github.com/google/shaka-player/issues/1967
+  it('does not change duration when 0', () => {
+    setupVod();
+    mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData);
+    createStreamingEngine();
+
+    onStartupComplete.and.callFake(() => setupFakeGetTime(0));
+    onChooseStreams.and.callFake(defaultOnChooseStreams);
+
+    // The duration can spuriously be set to 0, so we should ignore this and not
+    // update the duration.
+    mediaSourceEngine.getDuration.and.returnValue(0);
+
+    // Here we go!
+    streamingEngine.start();
+
+    runTest();
+    expect(mediaSourceEngine.endOfStream).toHaveBeenCalled();
+    expect(timeline.setDuration).not.toHaveBeenCalled();
+  });
+
   it('applies fudge factor for appendWindowStart', function() {
     setupVod();
     mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData);
@@ -1118,6 +1142,7 @@ describe('StreamingEngine', function() {
       });
 
       playing = false;
+      presentationTimeInSeconds = 0;
       createStreamingEngine();
 
       onStartupComplete.and.callFake(setupFakeGetTime.bind(null, 0));
@@ -1932,6 +1957,26 @@ describe('StreamingEngine', function() {
       runTest();
       expect(onError).toHaveBeenCalled();
     });
+
+    it('from failed clear in switchVariant', () => {
+      const expectedError = new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MEDIA,
+          shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_FAILED);
+      mediaSourceEngine.clear.and.returnValue(Promise.reject(expectedError));
+
+      onError.and.stub();
+      onChooseStreams.and.callFake((period) => defaultOnChooseStreams(period));
+      onStartupComplete.and.callFake(() => {
+        streamingEngine.switchVariant(
+            variant2, /* clear_buffer= */ true, /* safe_margin= */ 0);
+      });
+
+      // Here we go!
+      streamingEngine.start().catch(fail);
+      runTest();
+      expect(onError).toHaveBeenCalledWith(Util.jasmineError(expectedError));
+    });
   });
 
   describe('handles network errors', function() {

package/test/media/transmuxer_integration.js

@@ -59,6 +59,12 @@ describe('Transmuxer', function() {
       expect(isSupported(transportStreamVideoMimeType, ContentType.VIDEO))
           .toBe(true);
     });
+
+    // Issue #1991
+    it('handles upper-case MIME types', () => {
+      const mimeType = transportStreamVideoMimeType.replace('mp2t', 'MP2T');
+      expect(isSupported(mimeType, ContentType.VIDEO)).toBe(true);
+    });
   });
 
   describe('convertTsCodecs', function() {
@@ -86,6 +92,13 @@ describe('Transmuxer', function() {
           'video/mp2t; codecs="avc1.66.1"')).toEqual(
           'video/mp4; codecs="avc1.420001"');
     });
+
+    // Issue #1991
+    it('handles upper-case MIME types', () => {
+      expect(convertTsCodecs(
+          ContentType.VIDEO, 'video/MP2T; codecs="avc1.420001"'))
+          .toBe('video/mp4; codecs="avc1.420001"');
+    });
   });
 
   describe('transmuxing', function() {

package/test/net/data_uri_plugin_unit.js

@@ -65,10 +65,16 @@ describe('DataUriPlugin', function() {
   });
 
   function testSucceeds(uri, contentType, text, done) {
+    // An arbitrary request type.
+    const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
+    // A dummy progress callback.
+    const progressUpdated = (elapsedMs, bytes, bytesRemaining) => {};
+
     let request =
         shaka.net.NetworkingEngine.makeRequest([uri], retryParameters);
+
     // eslint-disable-next-line new-cap
-    shaka.net.DataUriPlugin(uri, request).promise
+    shaka.net.DataUriPlugin(uri, request, requestType, progressUpdated).promise
         .then(function(response) {
           expect(response).toBeTruthy();
           expect(response.uri).toBe(uri);
@@ -82,10 +88,15 @@ describe('DataUriPlugin', function() {
   }
 
   function testFails(uri, done, code) {
+    // An arbitrary request type.
+    const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
+    // A dummy progress callback.
+    const progressUpdated = (elapsedMs, bytes, bytesRemaining) => {};
+
     let request =
         shaka.net.NetworkingEngine.makeRequest([uri], retryParameters);
     // eslint-disable-next-line new-cap
-    shaka.net.DataUriPlugin(uri, request).promise
+    shaka.net.DataUriPlugin(uri, request, requestType, progressUpdated).promise
         .then(fail)
         .catch(function(error) { expect(error.code).toBe(code); })
         .then(function() {

package/test/net/http_plugin_unit.js

@@ -25,6 +25,9 @@ function httpPluginTests(usingFetch) {
   // Neither plugin uses the request type, so this is arbitrary.
   const requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
 
+  // A dummy progress callback.
+  const progressUpdated = (elapsedMs, bytes, bytesRemaining) => {};
+
   /** @type {shaka.extern.RetryParameters} */
   let retryParameters;
 
@@ -169,9 +172,9 @@ function httpPluginTests(usingFetch) {
     request.method = 'POST';
     request.headers['BAZ'] = '123';
 
-    plugin(request.uris[0], request, requestType).promise
-        .then(function() {
-          let actual = mostRecentRequest();
+    plugin(request.uris[0], request, requestType, progressUpdated).promise
+        .then(() => {
+          const actual = mostRecentRequest();
           expect(actual).toBeTruthy();
           expect(actual.url).toBe(request.uris[0]);
           expect(actual.method).toBe(request.method);
@@ -193,9 +196,9 @@ function httpPluginTests(usingFetch) {
       request.body = null;
       request.method = 'GET';
 
-      plugin(request.uris[0], request, requestType).promise
-          .then(function() {
-            let actual = jasmine.Fetch.requests.mostRecent();
+      plugin(request.uris[0], request, requestType, progressUpdated).promise
+          .then(() => {
+            const actual = jasmine.Fetch.requests.mostRecent();
             expect(actual).toBeTruthy();
             expect(actual.body).toBeUndefined();
           })
@@ -267,7 +270,7 @@ function httpPluginTests(usingFetch) {
   it('detects cache headers', function(done) {
     let request = shaka.net.NetworkingEngine.makeRequest(
         ['https://foo.bar/cache'], retryParameters);
-    plugin(request.uris[0], request, requestType).promise
+    plugin(request.uris[0], request, requestType, progressUpdated).promise
         .catch(fail)
         .then(function(response) {
           expect(response).toBeTruthy();
@@ -284,7 +287,8 @@ function httpPluginTests(usingFetch) {
     if (usingFetch) {
       let request = shaka.net.NetworkingEngine.makeRequest(
           ['https://foo.bar/timeout'], retryParameters);
-      let operation = plugin(request.uris[0], request, requestType);
+      const operation = plugin(
+          request.uris[0], request, requestType, progressUpdated);
 
       /** @type {jasmine.Fetch.RequestStub} */
       let actual = jasmine.Fetch.requests.mostRecent();
@@ -326,7 +330,8 @@ function httpPluginTests(usingFetch) {
 
       let request = shaka.net.NetworkingEngine.makeRequest(
           ['https://foo.bar/'], retryParameters);
-      operation = plugin(request.uris[0], request, requestType);
+      operation = plugin(
+          request.uris[0], request, requestType, progressUpdated);
       requestPromise = operation.promise;
     }
 
@@ -359,7 +364,7 @@ function httpPluginTests(usingFetch) {
   function testSucceeds(uri, done, overrideUri) {
     let request = shaka.net.NetworkingEngine.makeRequest(
         [uri], retryParameters);
-    plugin(uri, request, requestType).promise
+    plugin(uri, request, requestType, progressUpdated).promise
         .catch(fail)
         .then(function(response) {
           expect(mostRecentRequest().url).toBe(uri);
@@ -385,7 +390,7 @@ function httpPluginTests(usingFetch) {
   function testFails(uri, done, severity, code, errorData) {
     let request = shaka.net.NetworkingEngine.makeRequest(
         [uri], retryParameters);
-    plugin(uri, request, requestType).promise
+    plugin(uri, request, requestType, progressUpdated).promise
         .then(fail)
         .catch(function(error) {
           expect(error).toBeTruthy();
@@ -414,7 +419,7 @@ function httpPluginTests(usingFetch) {
   function testSucceedsWithEmptyLine(uri, done, overrideUri) {
     let request = shaka.net.NetworkingEngine.makeRequest(
         [uri], retryParameters);
-    plugin(uri, request, requestType).promise
+    plugin(uri, request, requestType, progressUpdated).promise
         .catch(fail)
         .then(function(response) {
           expect(mostRecentRequest().url).toBe(uri);

package/test/net/networking_engine_unit.js

@@ -124,7 +124,7 @@ describe('NetworkingEngine', /** @suppress {accessControls} */ function() {
           });
     });
 
-    it('will fail overall', function(done) {
+    it('will fail overall', async () => {
       let request = createRequest('reject://foo', {
         maxAttempts: 3,
         baseDelay: 0,
@@ -132,13 +132,22 @@ describe('NetworkingEngine', /** @suppress {accessControls} */ function() {
         fuzzFactor: 0,
         timeout: 0,
       });
-      networkingEngine.request(requestType, request).promise
-          .then(fail)
-          .catch(function(error) {
-            // It is expected to fail with the most recent error.
-            expect(error).toEqual(jasmine.any(shaka.util.Error));
-            expect(rejectScheme.calls.count()).toBe(3);
-          }).then(done);
+
+      // It is expected to fail with the most recent error, but at a CRITICAL
+      // severity, even though the original is at RECOVERABLE.
+
+      // Check our expectations.
+      expect(error.severity).toEqual(shaka.util.Error.Severity.RECOVERABLE);
+
+      // Modify the expected error.  Note that |expected| here is a wrapper
+      // created by jasmine, and |expected.sample| is the Object containing the
+      // expected values.
+      const expected = Util.jasmineError(error);
+      expected.sample.severity = shaka.util.Error.Severity.CRITICAL;
+
+      await expectAsync(networkingEngine.request(requestType, request).promise)
+          .toBeRejectedWith(expected);
+      expect(rejectScheme.calls.count()).toBe(3);
     });
 
     describe('backoff', function() {

package/test/offline/offline_scheme_unit.js

@@ -15,8 +15,14 @@
  * limitations under the License.
  */
 
-describe('OfflineScheme', function() {
-  beforeEach(checkAndRun(async function() {
+describe('OfflineScheme', () => {
+  // An arbitrary request type.
+  const requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
+
+  // A dummy progress callback.
+  const progressUpdated = (elapsedMs, bytes, bytesRemaining) => {};
+
+  beforeEach(checkAndRun(async () => {
     // Make sure we start with a clean slate.
     await clearStorage();
   }));
@@ -35,8 +41,8 @@ describe('OfflineScheme', function() {
             'mechanism', 'cell', 1024);
 
         // eslint-disable-next-line new-cap
-        let response = await shaka.offline.OfflineScheme(
-            uri.toString(), request).promise;
+        const response = await shaka.offline.OfflineScheme(
+            uri.toString(), request, requestType, progressUpdated).promise;
 
         expect(response).toBeTruthy();
         expect(response.uri).toBe(uri.toString());
@@ -64,8 +70,8 @@ describe('OfflineScheme', function() {
     }
 
     // eslint-disable-next-line new-cap
-    let response = await shaka.offline.OfflineScheme(
-        uri.toString(), request).promise;
+    const response = await shaka.offline.OfflineScheme(
+        uri.toString(), request, requestType, progressUpdated).promise;
 
     expect(response).toBeTruthy();
     expect(response.data.byteLength).toBe(segment.data.byteLength);
@@ -95,7 +101,9 @@ describe('OfflineScheme', function() {
 
     try {
       // eslint-disable-next-line new-cap
-      await shaka.offline.OfflineScheme(uri.toString(), request).promise;
+      const op = shaka.offline.OfflineScheme(
+          uri.toString(), request, requestType, progressUpdated);
+      await op.promise;
       fail();
     } catch (e) {
       expect(e.code).toBe(shaka.util.Error.Code.KEY_NOT_FOUND);
@@ -108,7 +116,9 @@ describe('OfflineScheme', function() {
 
     try {
       // eslint-disable-next-line new-cap
-      await shaka.offline.OfflineScheme(uri, request).promise;
+      const op = shaka.offline.OfflineScheme(
+          uri, request, requestType, progressUpdated);
+      await op.promise;
       fail();
     } catch (e) {
       expect(e.code).toBe(shaka.util.Error.Code.MALFORMED_OFFLINE_URI);

package/test/player_external.js

@@ -89,7 +89,7 @@ describe('Player', () => {
 
       let wit = asset.focus ? fit : it;
       wit(testName, async () => {
-        if (asset.drm.length &&
+        if (!asset.isClear() &&
             !asset.drm.some((keySystem) => support.drm[keySystem])) {
           pending('None of the required key systems are supported.');
         }
@@ -102,7 +102,8 @@ describe('Player', () => {
           if (asset.features.includes(Feature.MP4)) {
             mimeTypes.push('video/mp4');
           }
-          if (!mimeTypes.some((type) => support.media[type])) {
+          if (mimeTypes.length &&
+              !mimeTypes.some((type) => support.media[type])) {
             pending('None of the required MIME types are supported.');
           }
         }

package/test/player_integration.js

@@ -137,11 +137,11 @@ describe('Player', function() {
         // This should not be null initially.
         expect(textTrack.cues).not.toBe(null);
 
-        player.setTextTrackVisibility(true);
+        await player.setTextTrackVisibility(true);
         // This should definitely not be null when visible.
         expect(textTrack.cues).not.toBe(null);
 
-        player.setTextTrackVisibility(false);
+        await player.setTextTrackVisibility(false);
         // This should not transition to null when invisible.
         expect(textTrack.cues).not.toBe(null);
       }
@@ -281,7 +281,6 @@ describe('Player', function() {
       expect(textTracks[0].language).toEqual('en');
     });
 
-
     it('while changing languages with short Periods', async () => {
       // See: https://github.com/google/shaka-player/issues/797
       player.configure({preferredAudioLanguage: 'en'});
@@ -308,6 +307,23 @@ describe('Player', function() {
       expect(getActiveLanguage()).toBe('es');
     });
 
+    it('at higher playback rates', async () => {
+      await player.load('test:sintel_compiled');
+      video.play();
+      await waitUntilPlayheadReaches(eventManager, video, 1, 10);
+
+      // Enabling trick play should change our playback rate to the same rate.
+      player.trickPlay(2);
+      expect(video.playbackRate).toBe(2);
+
+      // Let playback continue playing for a bit longer.
+      await shaka.test.Util.delay(2);
+
+      // Cancelling trick play should return our playback rate to normal.
+      player.cancelTrickPlay();
+      expect(video.playbackRate).toBe(1);
+    });
+
     /**
      * Gets the language of the active Variant.
      * @return {string}
@@ -448,6 +464,81 @@ describe('Player', function() {
       }).catch(fail).then(done);
     });
   });
+
+  describe('tracks', () => {
+    // This is a regression test for b/138941217, in which tracks briefly
+    // vanished during the loading process.  On Chromecast devices, where the
+    // timing is very different from on desktop, this could occur such that
+    // there were no tracks after load() is resolved.
+    // This is an integration test so that we can check the behavior of the
+    // Player against actual platform behavior on all supported platforms.
+    it('remain available at every stage of loading', async () => {
+      let tracksFound = false;
+
+      /**
+       * @param {string} when When the check takes place.
+       *
+       * Will fail the test if tracks disappear after they first become
+       * available.
+       */
+      const checkTracks = (when) => {
+        // If tracks have already been found, expect them to still be found.
+        const tracksNow = player.getVariantTracks().length != 0;
+        if (tracksFound) {
+          expect(tracksNow).toBe(true);
+        } else {
+          // If tracks are now found, they should not, at any point during
+          // the loading process, disappear again.
+          if (tracksNow) {
+            tracksFound = true;
+          }
+        }
+        shaka.log.debug(
+            'checkTracks', when,
+            'tracksFound=', tracksFound,
+            'tracksNow=', tracksNow);
+      };
+
+      /** @param {Event} event */
+      const checkOnEvent = (event) => {
+        checkTracks(event.type + ' event');
+      };
+
+      // On each of these events, we will notice when tracks first appear, and
+      // verify that they never disappear at any point in the loading sequence.
+      eventManager.listen(video, 'canplay', checkOnEvent);
+      eventManager.listen(video, 'canplaythrough', checkOnEvent);
+      eventManager.listen(video, 'durationchange', checkOnEvent);
+      eventManager.listen(video, 'emptied', checkOnEvent);
+      eventManager.listen(video, 'loadeddata', checkOnEvent);
+      eventManager.listen(video, 'loadedmetadata', checkOnEvent);
+      eventManager.listen(video, 'loadstart', checkOnEvent);
+      eventManager.listen(video, 'pause', checkOnEvent);
+      eventManager.listen(video, 'play', checkOnEvent);
+      eventManager.listen(video, 'playing', checkOnEvent);
+      eventManager.listen(video, 'seeked', checkOnEvent);
+      eventManager.listen(video, 'seeking', checkOnEvent);
+      eventManager.listen(video, 'stalled', checkOnEvent);
+      eventManager.listen(video, 'waiting', checkOnEvent);
+      eventManager.listen(player, 'trackschanged', checkOnEvent);
+
+      const waiter = (new shaka.test.Waiter(eventManager)).timeoutAfter(10);
+      const canPlayThrough = waiter.waitForEvent(video, 'canplaythrough');
+
+      // Important: use a stream that starts somewhere other than zero, so that
+      // the video element's time is initially different from the start time of
+      // playback, and there is no content at time zero.
+      await player.load('test:sintel_start_at_3_compiled', 5);
+      shaka.log.debug('load resolved');
+
+      // When load is resolved(), tracks should definitely exist.
+      expect(tracksFound).toBe(true);
+
+      // Let the test keep running until we can play through.  In the original
+      // bug, tracks would disappear _after_ load() on some platforms.
+      await canPlayThrough;
+    });
+  });
 });
 
 // TODO(vaage): Try to group the stat tests together.

package/test/player_src_equals_integration.js

@@ -278,10 +278,10 @@ describe('Player Src Equals', () => {
 
     expect(player.isTextTrackVisible()).toBe(false);
 
-    player.setTextTrackVisibility(true);
+    await player.setTextTrackVisibility(true);
     expect(player.isTextTrackVisible()).toBe(true);
 
-    player.setTextTrackVisibility(false);
+    await player.setTextTrackVisibility(false);
     expect(player.isTextTrackVisible()).toBe(false);
   });
 

package/test/player_unit.js

@@ -308,30 +308,30 @@ describe('Player', function() {
 
       it('load text stream if caption is visible', async () => {
         await player.load(fakeManifestUri, 0, returnManifest(manifest));
-        player.setTextTrackVisibility(true);
+        await player.setTextTrackVisibility(true);
         expect(streamingEngine.loadNewTextStream).toHaveBeenCalled();
         expect(streamingEngine.getBufferingText()).not.toBe(null);
       });
 
       it('does not load text stream if caption is invisible', async () => {
         await player.load(fakeManifestUri, 0, returnManifest(manifest));
-        player.setTextTrackVisibility(false);
+        await player.setTextTrackVisibility(false);
         expect(streamingEngine.loadNewTextStream).not.toHaveBeenCalled();
         expect(streamingEngine.getBufferingText()).toBe(null);
       });
 
       it('loads text stream if alwaysStreamText is set', async () => {
-        player.setTextTrackVisibility(false);
+        await player.setTextTrackVisibility(false);
         player.configure({streaming: {alwaysStreamText: true}});
 
         await player.load(fakeManifestUri, 0, returnManifest(manifest));
         expect(streamingEngine.getBufferingText()).not.toBe(null);
 
-        player.setTextTrackVisibility(true);
+        await player.setTextTrackVisibility(true);
         expect(streamingEngine.loadNewTextStream).not.toHaveBeenCalled();
         expect(streamingEngine.unloadTextStream).not.toHaveBeenCalled();
 
-        player.setTextTrackVisibility(false);
+        await player.setTextTrackVisibility(false);
         expect(streamingEngine.loadNewTextStream).not.toHaveBeenCalled();
         expect(streamingEngine.unloadTextStream).not.toHaveBeenCalled();
       });
@@ -1569,6 +1569,19 @@ describe('Player', function() {
       expect(getActiveTextTrack().language).toBe('en');
     });
 
+    // https://github.com/google/shaka-player/issues/2010
+    it('changing text lang changes active stream when not streaming', () => {
+      streamingEngine.onCanSwitch();
+      player.setTextTrackVisibility(false);
+
+      expect(getActiveTextTrack().language).not.toBe('en');
+      expect(streamingEngine.switchTextStream).not.toHaveBeenCalled();
+      player.selectTextLanguage('en');
+
+      expect(streamingEngine.switchTextStream).not.toHaveBeenCalled();
+      expect(getActiveTextTrack().language).toBe('en');
+    });
+
     it('remembers the channel count when ABR is reenabled', () => {
       streamingEngine.onCanSwitch();
 
@@ -1701,7 +1714,7 @@ describe('Player', function() {
       expect(player.isTextTrackVisible()).toBe(true);
 
       // Turn text back off.
-      player.setTextTrackVisibility(false);
+      await player.setTextTrackVisibility(false);
       expect(player.isTextTrackVisible()).toBe(false);
 
       // Change text languages after startup.
@@ -2817,8 +2830,8 @@ describe('Player', function() {
   });
 
   describe('setTextTrackVisibility', function() {
-    it('does not throw before load', function() {
-      player.setTextTrackVisibility(true);
+    it('does not throw before load', async function() {
+      await player.setTextTrackVisibility(true);
     });
   });
 

package/test/test/boot.js

@@ -102,8 +102,10 @@ function getClientArg(name) {
   // the first time it needs to schedule something.
   Promise.resolve().then(function() {});
 
-  // Set the default timeout to 120s for all asynchronous tests.
-  jasmine.DEFAULT_TIMEOUT_INTERVAL = 120 * 1000;
+  const timeout = getClientArg('testTimeout');
+  if (timeout) {
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = Number(timeout);
+  }
 
   let logLevel = getClientArg('logLevel');
   if (logLevel) {
@@ -199,9 +201,12 @@ function getClientArg(name) {
     // Load required AMD modules, then proceed with tests.
     require(['promise-mock', 'sprintf-js', 'less'],
         (PromiseMock, sprintfJs, less) => {
-      window.PromiseMock = PromiseMock;
-      window.sprintf = sprintfJs.sprintf;
-      window.less = less;
+      // These external interfaces are declared as "const" in the externs.
+      // Avoid "const"-ness complaints from the compiler by assigning these
+      // using bracket notation.
+      window['PromiseMock'] = PromiseMock;
+      window['sprintf'] = sprintfJs.sprintf;
+      window['less'] = less;
 
       // Patch a new convenience method into PromiseMock.
       // See https://github.com/taylorhakes/promise-mock/issues/7
@@ -231,4 +236,14 @@ function getClientArg(name) {
       originalSetTimeout(done, 100 /* ms */);
     });
   }
+
+  // Code in karma-jasmine's adapter will malform test failures when the
+  // expectation message contains a stack trace, losing the failure message and
+  // mixing up the stack trace of the failure.  To avoid this, we modify
+  // shaka.util.Error not to create a stack trace.  This trace is not available
+  // in production, and there is never any need for it in the tests.
+  // Shimming shaka.util.Error proved too complicated because of a combination
+  // of compiler restrictions and ES6 language features, so this is by far the
+  // simpler answer.
+  shaka.util.Error.createStack = false;
 })();

package/test/test/externs/jasmine.js

@@ -65,6 +65,13 @@ jasmine.Spec.prototype.getFullName = function() {};
 jasmine.Matchers = function() {};
 
 
+/**
+ * @constructor
+ * @struct
+ */
+jasmine.MatchersAsync = function() {};
+
+
 /**
  * @param {*} value
  * @return {!jasmine.Matchers}
@@ -72,6 +79,13 @@ jasmine.Matchers = function() {};
 var expect = function(value) {};
 
 
+/**
+ * @param {!Promise} value
+ * @return {!jasmine.MatchersAsync}
+ */
+var expectAsync = function(value) {};
+
+
 /** @param {string=} message */
 var pending = function(message) {};
 
@@ -173,6 +187,40 @@ jasmine.Matchers.prototype.toHaveBeenCalledOnceMore = function() {};
  */
 jasmine.Matchers.prototype.toHaveBeenCalledOnceMoreWith = function(args) {};
 
+/**
+ * @param {string} message
+ * @return {!jasmine.Matchers}
+ */
+jasmine.Matchers.prototype.withContext = function(message) {};
+
+
+/** @type {!jasmine.MatchersAsync} */
+jasmine.MatchersAsync.prototype.not;
+
+/** @return {!Promise} */
+jasmine.MatchersAsync.prototype.toBeRejected = function() {};
+
+/**
+ * @param {*} expected
+ * @return {!Promise}
+ */
+jasmine.MatchersAsync.prototype.toBeRejectedWith = function(expected) {};
+
+/** @return {!Promise} */
+jasmine.MatchersAsync.prototype.toBeResolved = function() {};
+
+/**
+ * @param {*} expected
+ * @return {!Promise}
+ */
+jasmine.MatchersAsync.prototype.toBeResolvedTo = function(expected) {};
+
+/**
+ * @param {string} message
+ * @return {!jasmine.MatchersAsync}
+ */
+jasmine.MatchersAsync.prototype.withContext = function(message) {};
+
 
 /**
  * @constructor