text: import {
    BufferLoader,
    Resource,
    ResourceCache,
    when,
  } from "../Source/Cesium.js";
  
  describe("Scene/BufferLoader", function () {
    var typedArray = new Uint8Array([1, 3, 7, 15, 31, 63, 127, 255]);
    var arrayBuffer = typedArray.buffer;
    var resource = new Resource({ url: "https://example.com/external.bin" });
  
    afterEach(function () {
      ResourceCache.clearForSpecs();
    });
  
    it("throws if neither options.typedArray nor options.resource are defined", function () {
      expect(function () {
        return new BufferLoader({
          typedArray: undefined,
          resource: undefined,
        });
      }).toThrowDeveloperError();
    });
  
    it("throws if both options.typedArray and options.resource are defined", function () {
      expect(function () {
        return new BufferLoader({
          typedArray: typedArray,
          resource: resource,
        });
      }).toThrowDeveloperError();
    });
  
    it("rejects promise if buffer cannot be fetched", function () {
      var error = new Error("404 Not Found");
      spyOn(Resource.prototype, "fetchArrayBuffer").and.returnValue(
        when.reject(error)
      );
  
      var bufferLoader = new BufferLoader({
        resource: resource,
      });
  
      bufferLoader.load();
  
      return bufferLoader.promise
        .then(function (bufferLoader) {
          fail();
        })
        .otherwise(function (runtimeError) {
          expect(runtimeError.message).toBe(
            "Failed to load external buffer: https://example.com/external.bin\n404 Not Found"
          );
        });
    });
  
    it("loads buffer from typed array", function () {
      var bufferLoader = new BufferLoader({
        typedArray: typedArray,
      });
      bufferLoader.load();
  
      return bufferLoader.promise.then(function (bufferLoader) {
        expect(bufferLoader.typedArray).toBe(typedArray);
      });
    });
  
    it("loads external buffer", function () {
      var fetchBuffer = spyOn(
        Resource.prototype,
        "fetchArrayBuffer"
      ).and.returnValue(when.resolve(arrayBuffer));
  
      var bufferLoader = new BufferLoader({
        resource: resource,
      });
  
      bufferLoader.load();
  
      return bufferLoader.promise.then(function (bufferLoader) {
        expect(fetchBuffer).toHaveBeenCalled();
        expect(bufferLoader.typedArray.buffer).toBe(arrayBuffer);
      });
    });
  
    it("destroys buffer", function () {
      spyOn(Resource.prototype, "fetchArrayBuffer").and.returnValue(
        when.resolve(arrayBuffer)
      );
  
      var bufferLoader = new BufferLoader({
        resource: resource,
      });
  
      expect(bufferLoader.typedArray).not.toBeDefined();
  
      bufferLoader.load();
  
      return bufferLoader.promise.then(function (bufferLoader) {
        expect(bufferLoader.typedArray.buffer).toBe(arrayBuffer);
        expect(bufferLoader.isDestroyed()).toBe(false);
  
        bufferLoader.destroy();
        expect(bufferLoader.typedArray).not.toBeDefined();
        expect(bufferLoader.isDestroyed()).toBe(true);
      });
    });
  
    function resolveAfterDestroy(reject) {
      var deferredPromise = when.defer();
      spyOn(Resource.prototype, "fetchArrayBuffer").and.returnValue(
        deferredPromise.promise
      );
  
      var bufferLoader = new BufferLoader({
        resource: resource,
      });
  
      expect(bufferLoader.typedArray).not.toBeDefined();
  
      bufferLoader.load();
      bufferLoader.destroy();
  
      if (reject) {
        deferredPromise.reject(new Error());
      } else {
        deferredPromise.resolve(arrayBuffer);
      }
  
      expect(bufferLoader.typedArray).not.toBeDefined();
      expect(bufferLoader.isDestroyed()).toBe(true);
    }
  
    it("handles resolving uri after destroy", function () {
      resolveAfterDestroy(false);
    });
  
    it("handles rejecting uri after destroy", function () {
      resolveAfterDestroy(true);
    });
  });
  