import { Clock } from "../../../Source/Cesium.js";
|
import { defaultValue } from "../../../Source/Cesium.js";
|
import { EllipsoidTerrainProvider } from "../../../Source/Cesium.js";
|
import { ScreenSpaceEventHandler } from "../../../Source/Cesium.js";
|
import { WebMercatorProjection } from "../../../Source/Cesium.js";
|
import { Camera } from "../../../Source/Cesium.js";
|
import { ImageryLayerCollection } from "../../../Source/Cesium.js";
|
import { Scene } from "../../../Source/Cesium.js";
|
import { SceneMode } from "../../../Source/Cesium.js";
|
import { SkyBox } from "../../../Source/Cesium.js";
|
import { TileCoordinatesImageryProvider } from "../../../Source/Cesium.js";
|
import DomEventSimulator from "../../DomEventSimulator.js";
|
import getWebGLStub from "../../getWebGLStub.js";
|
import pollToPromise from "../../pollToPromise.js";
|
import { CesiumWidget } from "../../../Source/Cesium.js";
|
|
describe(
|
"Widgets/CesiumWidget/CesiumWidget",
|
function () {
|
var container;
|
var widget;
|
beforeEach(function () {
|
container = document.createElement("div");
|
container.id = "container";
|
container.style.width = "1px";
|
container.style.height = "1px";
|
container.style.overflow = "hidden";
|
container.style.position = "relative";
|
document.body.appendChild(container);
|
});
|
|
afterEach(function () {
|
if (widget && !widget.isDestroyed()) {
|
widget = widget.destroy();
|
}
|
document.body.removeChild(container);
|
});
|
|
function createCesiumWidget(container, options) {
|
options = defaultValue(options, {});
|
options.contextOptions = defaultValue(options.contextOptions, {});
|
options.contextOptions.webgl = defaultValue(
|
options.contextOptions.webgl,
|
{}
|
);
|
if (!!window.webglStub) {
|
options.contextOptions.getWebGLStub = getWebGLStub;
|
}
|
|
return new CesiumWidget(container, options);
|
}
|
|
it("can create, render, and destroy", function () {
|
widget = createCesiumWidget(container);
|
expect(widget.isDestroyed()).toEqual(false);
|
expect(widget.container).toBeInstanceOf(HTMLElement);
|
expect(widget.canvas).toBeInstanceOf(HTMLElement);
|
expect(widget.creditContainer).toBeInstanceOf(HTMLElement);
|
expect(widget.creditViewport).toBeInstanceOf(HTMLElement);
|
expect(widget.scene).toBeInstanceOf(Scene);
|
expect(widget.imageryLayers).toBeInstanceOf(ImageryLayerCollection);
|
expect(widget.terrainProvider).toBeInstanceOf(EllipsoidTerrainProvider);
|
expect(widget.camera).toBeInstanceOf(Camera);
|
expect(widget.clock).toBeInstanceOf(Clock);
|
expect(widget.screenSpaceEventHandler).toBeInstanceOf(
|
ScreenSpaceEventHandler
|
);
|
expect(widget.useBrowserRecommendedResolution).toBe(true);
|
widget.render();
|
widget.destroy();
|
expect(widget.isDestroyed()).toEqual(true);
|
});
|
|
it("can pass id string for container", function () {
|
widget = createCesiumWidget("container");
|
});
|
|
it("sets expected options clock", function () {
|
var options = {
|
clock: new Clock(),
|
};
|
widget = createCesiumWidget(container, options);
|
expect(widget.clock).toBe(options.clock);
|
});
|
|
it("can set scene mode 2D", function () {
|
widget = createCesiumWidget(container, {
|
sceneMode: SceneMode.SCENE2D,
|
});
|
widget.scene.completeMorph();
|
expect(widget.scene.mode).toBe(SceneMode.SCENE2D);
|
});
|
|
it("can set map projection", function () {
|
var mapProjection = new WebMercatorProjection();
|
|
widget = createCesiumWidget(container, {
|
mapProjection: mapProjection,
|
});
|
expect(widget.scene.mapProjection).toEqual(mapProjection);
|
});
|
|
it("can set scene mode Columbus", function () {
|
widget = createCesiumWidget(container, {
|
sceneMode: SceneMode.COLUMBUS_VIEW,
|
});
|
widget.scene.completeMorph();
|
expect(widget.scene.mode).toBe(SceneMode.COLUMBUS_VIEW);
|
});
|
|
it("can disable render loop", function () {
|
widget = createCesiumWidget(container, {
|
useDefaultRenderLoop: false,
|
});
|
expect(widget.useDefaultRenderLoop).toBe(false);
|
});
|
|
it("can set target frame rate", function () {
|
widget = createCesiumWidget(container, {
|
targetFrameRate: 23,
|
});
|
expect(widget.targetFrameRate).toBe(23);
|
});
|
|
it("sets expected options imageryProvider", function () {
|
var options = {
|
imageryProvider: new TileCoordinatesImageryProvider(),
|
};
|
widget = createCesiumWidget(container, options);
|
var imageryLayers = widget.scene.imageryLayers;
|
expect(imageryLayers.length).toEqual(1);
|
expect(imageryLayers.get(0).imageryProvider).toBe(
|
options.imageryProvider
|
);
|
});
|
|
it("does not create an ImageryProvider if option is false", function () {
|
widget = createCesiumWidget(container, {
|
imageryProvider: false,
|
});
|
var imageryLayers = widget.scene.imageryLayers;
|
expect(imageryLayers.length).toEqual(0);
|
});
|
|
it("sets expected options terrainProvider", function () {
|
var options = {
|
terrainProvider: new EllipsoidTerrainProvider(),
|
};
|
widget = createCesiumWidget(container, options);
|
expect(widget.terrainProvider).toBe(options.terrainProvider);
|
|
var anotherProvider = new EllipsoidTerrainProvider();
|
widget.terrainProvider = anotherProvider;
|
expect(widget.terrainProvider).toBe(anotherProvider);
|
});
|
|
it("does not create a globe if option is false", function () {
|
widget = createCesiumWidget(container, {
|
globe: false,
|
});
|
expect(widget.scene.globe).not.toBeDefined();
|
});
|
|
it("does not create a skyBox if option is false", function () {
|
widget = createCesiumWidget(container, {
|
skyBox: false,
|
});
|
expect(widget.scene.skyBox).not.toBeDefined();
|
});
|
|
it("does not create a skyAtmosphere if option is false", function () {
|
widget = createCesiumWidget(container, {
|
skyAtmosphere: false,
|
});
|
expect(widget.scene.skyAtmosphere).not.toBeDefined();
|
});
|
|
it("sets expected options skyBox", function () {
|
var options = {
|
skyBox: new SkyBox({
|
sources: {
|
positiveX: "./Data/Images/Blue.png",
|
negativeX: "./Data/Images/Green.png",
|
positiveY: "./Data/Images/Blue.png",
|
negativeY: "./Data/Images/Green.png",
|
positiveZ: "./Data/Images/Blue.png",
|
negativeZ: "./Data/Images/Green.png",
|
},
|
}),
|
};
|
widget = createCesiumWidget(container, options);
|
expect(widget.scene.skyBox).toBe(options.skyBox);
|
});
|
|
it("can set contextOptions", function () {
|
var webglOptions = {
|
alpha: true,
|
depth: true, //TODO Change to false when https://bugzilla.mozilla.org/show_bug.cgi?id=745912 is fixed.
|
stencil: true,
|
antialias: false,
|
premultipliedAlpha: true, // Workaround IE 11.0.8, which does not honor false.
|
preserveDrawingBuffer: true,
|
powerPreference: "low-power",
|
};
|
var contextOptions = {
|
allowTextureFilterAnisotropic: false,
|
webgl: webglOptions,
|
};
|
|
widget = createCesiumWidget(container, {
|
contextOptions: contextOptions,
|
});
|
|
var context = widget.scene.context;
|
var contextAttributes = context._gl.getContextAttributes();
|
|
expect(context.options.allowTextureFilterAnisotropic).toEqual(false);
|
expect(contextAttributes.alpha).toEqual(webglOptions.alpha);
|
expect(contextAttributes.depth).toEqual(webglOptions.depth);
|
expect(contextAttributes.stencil).toEqual(webglOptions.stencil);
|
expect(contextAttributes.antialias).toEqual(webglOptions.antialias);
|
expect(contextAttributes.premultipliedAlpha).toEqual(
|
webglOptions.premultipliedAlpha
|
);
|
expect(contextAttributes.powerPreference).toEqual(
|
webglOptions.powerPreference
|
);
|
expect(contextAttributes.preserveDrawingBuffer).toEqual(
|
webglOptions.preserveDrawingBuffer
|
);
|
});
|
|
it("can disable Order Independent Translucency", function () {
|
widget = createCesiumWidget(container, {
|
orderIndependentTranslucency: false,
|
});
|
expect(widget.scene.orderIndependentTranslucency).toBe(false);
|
});
|
|
it("can enable requestRenderMode", function () {
|
widget = createCesiumWidget(container, {
|
requestRenderMode: true,
|
});
|
|
expect(widget.scene.requestRenderMode).toBe(true);
|
});
|
|
it("can set maximumRenderTimeChange", function () {
|
widget = createCesiumWidget(container, {
|
maximumRenderTimeChange: Number.POSITIVE_INFINITY,
|
});
|
|
expect(widget.scene.maximumRenderTimeChange).toBe(
|
Number.POSITIVE_INFINITY
|
);
|
});
|
|
it("throws if no container provided", function () {
|
expect(function () {
|
return createCesiumWidget(undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("throws if targetFrameRate less than 0", function () {
|
widget = createCesiumWidget(container);
|
expect(function () {
|
widget.targetFrameRate = -1;
|
}).toThrowDeveloperError();
|
});
|
|
it("can set resolutionScale", function () {
|
widget = createCesiumWidget(container);
|
widget.resolutionScale = 0.5;
|
expect(widget.resolutionScale).toBe(0.5);
|
});
|
|
it("can enable useBrowserRecommendedResolution", function () {
|
widget = createCesiumWidget(container, {
|
useBrowserRecommendedResolution: true,
|
});
|
|
expect(widget.useBrowserRecommendedResolution).toBe(true);
|
});
|
|
it("useBrowserRecommendedResolution ignores devicePixelRatio", function () {
|
var oldDevicePixelRatio = window.devicePixelRatio;
|
window.devicePixelRatio = 2.0;
|
|
widget = createCesiumWidget(container, {
|
useDefaultRenderLoop: false,
|
});
|
|
widget.resolutionScale = 0.5;
|
|
widget.useBrowserRecommendedResolution = true;
|
widget.resize();
|
expect(widget.scene.pixelRatio).toEqual(0.5);
|
|
widget.useBrowserRecommendedResolution = false;
|
widget.resize();
|
expect(widget.scene.pixelRatio).toEqual(1.0);
|
|
window.devicePixelRatio = oldDevicePixelRatio;
|
});
|
|
it("throws if resolutionScale is less than 0", function () {
|
widget = createCesiumWidget(container);
|
expect(function () {
|
widget.resolutionScale = -1;
|
}).toThrowDeveloperError();
|
});
|
|
it("resizing triggers a render in requestRender mode", function () {
|
widget = createCesiumWidget(container, {
|
requestRenderMode: true,
|
maximumRenderTimeChange: Number.POSITIVE_INFINITY,
|
});
|
|
var scene = widget._scene;
|
spyOn(scene, "requestRender");
|
|
widget.resize();
|
|
expect(scene.requestRender).not.toHaveBeenCalled();
|
|
widget._forceResize = true;
|
widget.resize();
|
|
expect(scene.requestRender).toHaveBeenCalled();
|
});
|
|
it("throws if no container id does not exist", function () {
|
expect(function () {
|
return createCesiumWidget("doesnotexist");
|
}).toThrowDeveloperError();
|
});
|
|
it("stops the render loop when render throws", function () {
|
widget = createCesiumWidget(container);
|
expect(widget.useDefaultRenderLoop).toEqual(true);
|
|
var error = "foo";
|
widget.scene.primitives.update = function () {
|
throw error;
|
};
|
|
return pollToPromise(function () {
|
return !widget.useDefaultRenderLoop;
|
}, "render loop to be disabled.");
|
});
|
|
it("shows the error panel when render throws", function () {
|
widget = createCesiumWidget(container);
|
|
var error = "foo";
|
widget.scene.primitives.update = function () {
|
throw error;
|
};
|
|
return pollToPromise(function () {
|
return !widget.useDefaultRenderLoop;
|
}).then(function () {
|
expect(
|
widget._element.querySelector(".cesium-widget-errorPanel")
|
).not.toBeNull();
|
|
var messages = widget._element.querySelectorAll(
|
".cesium-widget-errorPanel-message"
|
);
|
|
var found = false;
|
for (var i = 0; i < messages.length; ++i) {
|
if (messages[i].textContent.indexOf(error) !== -1) {
|
found = true;
|
}
|
}
|
|
expect(found).toBe(true);
|
|
// click the OK button to dismiss the panel
|
DomEventSimulator.fireClick(
|
widget._element.querySelector(".cesium-button")
|
);
|
|
expect(
|
widget._element.querySelector(".cesium-widget-errorPanel")
|
).toBeNull();
|
});
|
});
|
|
it("does not show the error panel if disabled", function () {
|
widget = createCesiumWidget(container, {
|
showRenderLoopErrors: false,
|
});
|
|
var error = "foo";
|
widget.scene.primitives.update = function () {
|
throw error;
|
};
|
|
return pollToPromise(function () {
|
return !widget.useDefaultRenderLoop;
|
}).then(function () {
|
expect(
|
widget._element.querySelector(".cesium-widget-errorPanel")
|
).toBeNull();
|
});
|
});
|
},
|
"WebGL"
|
);
|
