505 lines
18 KiB
JavaScript
505 lines
18 KiB
JavaScript
defineSuite([
|
|
'DataSources/Entity',
|
|
'Core/Cartesian3',
|
|
'Core/JulianDate',
|
|
'Core/Matrix3',
|
|
'Core/Matrix4',
|
|
'Core/Quaternion',
|
|
'Core/TimeInterval',
|
|
'Core/TimeIntervalCollection',
|
|
'Core/Transforms',
|
|
'DataSources/BillboardGraphics',
|
|
'DataSources/BoxGraphics',
|
|
'DataSources/ConstantPositionProperty',
|
|
'DataSources/ConstantProperty',
|
|
'DataSources/CorridorGraphics',
|
|
'DataSources/CylinderGraphics',
|
|
'DataSources/EllipseGraphics',
|
|
'DataSources/EllipsoidGraphics',
|
|
'DataSources/LabelGraphics',
|
|
'DataSources/ModelGraphics',
|
|
'DataSources/PathGraphics',
|
|
'DataSources/PlaneGraphics',
|
|
'DataSources/PointGraphics',
|
|
'DataSources/PolygonGraphics',
|
|
'DataSources/PolylineGraphics',
|
|
'DataSources/PolylineVolumeGraphics',
|
|
'DataSources/RectangleGraphics',
|
|
'DataSources/WallGraphics'
|
|
], function(
|
|
Entity,
|
|
Cartesian3,
|
|
JulianDate,
|
|
Matrix3,
|
|
Matrix4,
|
|
Quaternion,
|
|
TimeInterval,
|
|
TimeIntervalCollection,
|
|
Transforms,
|
|
BillboardGraphics,
|
|
BoxGraphics,
|
|
ConstantPositionProperty,
|
|
ConstantProperty,
|
|
CorridorGraphics,
|
|
CylinderGraphics,
|
|
EllipseGraphics,
|
|
EllipsoidGraphics,
|
|
LabelGraphics,
|
|
ModelGraphics,
|
|
PathGraphics,
|
|
PlaneGraphics,
|
|
PointGraphics,
|
|
PolygonGraphics,
|
|
PolylineGraphics,
|
|
PolylineVolumeGraphics,
|
|
RectangleGraphics,
|
|
WallGraphics) {
|
|
'use strict';
|
|
|
|
it('constructor sets expected properties.', function() {
|
|
var entity = new Entity();
|
|
expect(entity.id).toBeDefined();
|
|
expect(entity.name).toBeUndefined();
|
|
expect(entity.billboard).toBeUndefined();
|
|
expect(entity.box).toBeUndefined();
|
|
expect(entity.corridor).toBeUndefined();
|
|
expect(entity.cylinder).toBeUndefined();
|
|
expect(entity.description).toBeUndefined();
|
|
expect(entity.ellipse).toBeUndefined();
|
|
expect(entity.ellipsoid).toBeUndefined();
|
|
expect(entity.label).toBeUndefined();
|
|
expect(entity.model).toBeUndefined();
|
|
expect(entity.orientation).toBeUndefined();
|
|
expect(entity.path).toBeUndefined();
|
|
expect(entity.plane).toBeUndefined();
|
|
expect(entity.point).toBeUndefined();
|
|
expect(entity.polygon).toBeUndefined();
|
|
expect(entity.polyline).toBeUndefined();
|
|
expect(entity.polylineVolume).toBeUndefined();
|
|
expect(entity.position).toBeUndefined();
|
|
expect(entity.rectangle).toBeUndefined();
|
|
expect(entity.viewFrom).toBeUndefined();
|
|
expect(entity.wall).toBeUndefined();
|
|
expect(entity.entityCollection).toBeUndefined();
|
|
|
|
var options = {
|
|
id : 'someId',
|
|
name : 'bob',
|
|
show : false,
|
|
availability : new TimeIntervalCollection(),
|
|
parent : new Entity(),
|
|
customProperty : {},
|
|
billboard : {},
|
|
box : {},
|
|
corridor : {},
|
|
cylinder : {},
|
|
description : 'description',
|
|
ellipse : {},
|
|
ellipsoid : {},
|
|
label : {},
|
|
model : {},
|
|
orientation : new Quaternion(1, 2, 3, 4),
|
|
path : {},
|
|
plane : {},
|
|
point : {},
|
|
polygon : {},
|
|
polyline : {},
|
|
polylineVolume : {},
|
|
position : new Cartesian3(5, 6, 7),
|
|
rectangle : {},
|
|
viewFrom : new Cartesian3(8, 9, 10),
|
|
wall : {}
|
|
};
|
|
|
|
entity = new Entity(options);
|
|
expect(entity.id).toEqual(options.id);
|
|
expect(entity.name).toEqual(options.name);
|
|
expect(entity.show).toBe(options.show);
|
|
expect(entity.availability).toBe(options.availability);
|
|
expect(entity.parent).toBe(options.parent);
|
|
expect(entity.customProperty).toBe(options.customProperty);
|
|
|
|
expect(entity.billboard).toBeInstanceOf(BillboardGraphics);
|
|
expect(entity.box).toBeInstanceOf(BoxGraphics);
|
|
expect(entity.corridor).toBeInstanceOf(CorridorGraphics);
|
|
expect(entity.cylinder).toBeInstanceOf(CylinderGraphics);
|
|
expect(entity.description).toBeInstanceOf(ConstantProperty);
|
|
expect(entity.ellipse).toBeInstanceOf(EllipseGraphics);
|
|
expect(entity.ellipsoid).toBeInstanceOf(EllipsoidGraphics);
|
|
expect(entity.label).toBeInstanceOf(LabelGraphics);
|
|
expect(entity.model).toBeInstanceOf(ModelGraphics);
|
|
expect(entity.orientation).toBeInstanceOf(ConstantProperty);
|
|
expect(entity.path).toBeInstanceOf(PathGraphics);
|
|
expect(entity.plane).toBeInstanceOf(PlaneGraphics);
|
|
expect(entity.point).toBeInstanceOf(PointGraphics);
|
|
expect(entity.polygon).toBeInstanceOf(PolygonGraphics);
|
|
expect(entity.polyline).toBeInstanceOf(PolylineGraphics);
|
|
expect(entity.polylineVolume).toBeInstanceOf(PolylineVolumeGraphics);
|
|
expect(entity.position).toBeInstanceOf(ConstantPositionProperty);
|
|
expect(entity.rectangle).toBeInstanceOf(RectangleGraphics);
|
|
expect(entity.viewFrom).toBeInstanceOf(ConstantProperty);
|
|
expect(entity.wall).toBeInstanceOf(WallGraphics);
|
|
|
|
expect(entity.entityCollection).toBeUndefined();
|
|
});
|
|
|
|
it('isAvailable is always true if no availability defined.', function() {
|
|
var entity = new Entity();
|
|
expect(entity.isAvailable(JulianDate.now())).toEqual(true);
|
|
});
|
|
|
|
it('isAvailable throw if no time specified.', function() {
|
|
var entity = new Entity();
|
|
expect(function() {
|
|
entity.isAvailable();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('constructor creates a unique id if one is not provided.', function() {
|
|
var object = new Entity();
|
|
var object2 = new Entity();
|
|
expect(object.id).toBeDefined();
|
|
expect(object.id).not.toEqual(object2.id);
|
|
});
|
|
|
|
it('isAvailable works.', function() {
|
|
var entity = new Entity();
|
|
var interval = TimeInterval.fromIso8601({
|
|
iso8601 : '2000-01-01/2001-01-01'
|
|
});
|
|
var intervals = new TimeIntervalCollection();
|
|
intervals.addInterval(interval);
|
|
entity.availability = intervals;
|
|
expect(entity.isAvailable(JulianDate.addSeconds(interval.start, -1, new JulianDate()))).toEqual(false);
|
|
expect(entity.isAvailable(interval.start)).toEqual(true);
|
|
expect(entity.isAvailable(interval.stop)).toEqual(true);
|
|
expect(entity.isAvailable(JulianDate.addSeconds(interval.stop, 1, new JulianDate()))).toEqual(false);
|
|
});
|
|
|
|
it('definitionChanged works for all properties', function() {
|
|
var entity = new Entity();
|
|
var propertyNames = entity.propertyNames;
|
|
var propertyNamesLength = propertyNames.length;
|
|
|
|
var listener = jasmine.createSpy('listener');
|
|
entity.definitionChanged.addEventListener(listener);
|
|
|
|
var i;
|
|
var name;
|
|
var newValue;
|
|
var oldValue;
|
|
//We loop through twice to ensure that oldValue is properly passed in.
|
|
for (var x = 0; x < 2; x++) {
|
|
for (i = 0; i < propertyNamesLength; i++) {
|
|
name = propertyNames[i];
|
|
newValue = new ConstantProperty(1);
|
|
oldValue = entity[propertyNames[i]];
|
|
entity[name] = newValue;
|
|
expect(listener).toHaveBeenCalledWith(entity, name, newValue, oldValue);
|
|
}
|
|
}
|
|
});
|
|
|
|
it('merge always overwrites availability', function() {
|
|
var entity = new Entity();
|
|
var interval = TimeInterval.fromIso8601({
|
|
iso8601 : '2000-01-01/2001-01-01'
|
|
});
|
|
entity.availability = interval;
|
|
|
|
var entity2 = new Entity();
|
|
var interval2 = TimeInterval.fromIso8601({
|
|
iso8601 : '2000-01-01/2001-01-01'
|
|
});
|
|
entity2.availability = interval2;
|
|
|
|
entity.merge(entity2);
|
|
expect(entity.availability).toBe(interval2);
|
|
});
|
|
|
|
it('merge works with custom properties.', function() {
|
|
var propertyName = 'customProperty';
|
|
var value = 'fizzbuzz';
|
|
|
|
var source = new Entity({
|
|
id : 'source'
|
|
});
|
|
source.addProperty(propertyName);
|
|
source[propertyName] = value;
|
|
|
|
var target = new Entity({
|
|
id : 'target'
|
|
});
|
|
|
|
//Merging should actually call addProperty for the customProperty.
|
|
spyOn(target, 'addProperty').and.callThrough();
|
|
target.merge(source);
|
|
|
|
expect(target.addProperty).toHaveBeenCalledWith(propertyName);
|
|
expect(target[propertyName]).toEqual(source[propertyName]);
|
|
});
|
|
|
|
it('merge throws with undefined source', function() {
|
|
var entity = new Entity();
|
|
expect(function() {
|
|
entity.merge(undefined);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('computeModelMatrix throws if no time specified.', function() {
|
|
var entity = new Entity();
|
|
expect(function() {
|
|
entity.computeModelMatrix();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('computeModelMatrix returns undefined when position is undefined.', function() {
|
|
var entity = new Entity();
|
|
entity.orientation = new ConstantProperty(Quaternion.IDENTITY);
|
|
expect(entity.computeModelMatrix(new JulianDate())).toBeUndefined();
|
|
});
|
|
|
|
it('computeModelMatrix returns correct value.', function() {
|
|
var entity = new Entity();
|
|
|
|
var position = new Cartesian3(123456, 654321, 123456);
|
|
var orientation = new Quaternion(1, 2, 3, 4);
|
|
Quaternion.normalize(orientation, orientation);
|
|
|
|
entity.position = new ConstantProperty(position);
|
|
entity.orientation = new ConstantProperty(orientation);
|
|
|
|
var modelMatrix = entity.computeModelMatrix(new JulianDate());
|
|
var expected = Matrix4.fromRotationTranslation(Matrix3.fromQuaternion(orientation), position);
|
|
expect(modelMatrix).toEqual(expected);
|
|
});
|
|
|
|
it('computeModelMatrix returns ENU when quaternion is undefined.', function() {
|
|
var entity = new Entity();
|
|
var position = new Cartesian3(123456, 654321, 123456);
|
|
entity.position = new ConstantProperty(position);
|
|
|
|
var modelMatrix = entity.computeModelMatrix(new JulianDate());
|
|
var expected = Transforms.eastNorthUpToFixedFrame(position);
|
|
expect(modelMatrix).toEqual(expected);
|
|
});
|
|
|
|
it('computeModelMatrix works with result parameter.', function() {
|
|
var entity = new Entity();
|
|
var position = new Cartesian3(123456, 654321, 123456);
|
|
entity.position = new ConstantProperty(position);
|
|
|
|
var result = new Matrix4();
|
|
var modelMatrix = entity.computeModelMatrix(new JulianDate(), result);
|
|
var expected = Transforms.eastNorthUpToFixedFrame(position);
|
|
expect(modelMatrix).toBe(result);
|
|
expect(modelMatrix).toEqual(expected);
|
|
});
|
|
|
|
it('can add and remove custom properties.', function() {
|
|
var entity = new Entity();
|
|
expect(entity.hasOwnProperty('bob')).toBe(false);
|
|
expect(entity.propertyNames).not.toContain('bob');
|
|
|
|
entity.addProperty('bob');
|
|
expect(entity.hasOwnProperty('bob')).toBe(true);
|
|
expect(entity.propertyNames).toContain('bob');
|
|
|
|
entity.removeProperty('bob');
|
|
expect(entity.hasOwnProperty('bob')).toBe(false);
|
|
expect(entity.propertyNames).not.toContain('bob');
|
|
});
|
|
|
|
it('can re-add removed properties', function() {
|
|
var entity = new Entity();
|
|
entity.addProperty('bob');
|
|
entity.removeProperty('bob');
|
|
entity.addProperty('bob');
|
|
expect(entity.hasOwnProperty('bob')).toBe(true);
|
|
expect(entity.propertyNames).toContain('bob');
|
|
});
|
|
|
|
it('addProperty throws with no property specified.', function() {
|
|
var entity = new Entity();
|
|
expect(function() {
|
|
entity.addProperty(undefined);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('addProperty throws with no property specified.', function() {
|
|
var entity = new Entity();
|
|
expect(function() {
|
|
entity.addProperty(undefined);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('removeProperty throws with no property specified.', function() {
|
|
var entity = new Entity();
|
|
expect(function() {
|
|
entity.removeProperty(undefined);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('addProperty throws when adding an existing property.', function() {
|
|
var entity = new Entity();
|
|
entity.addProperty('bob');
|
|
expect(function() {
|
|
entity.addProperty('bob');
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('removeProperty throws when non-existent property.', function() {
|
|
var entity = new Entity();
|
|
expect(function() {
|
|
entity.removeProperty('bob');
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('addProperty throws with defined reserved property name.', function() {
|
|
var entity = new Entity();
|
|
expect(function() {
|
|
entity.addProperty('merge');
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('removeProperty throws with defined reserved property name.', function() {
|
|
var entity = new Entity();
|
|
expect(function() {
|
|
entity.removeProperty('merge');
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('addProperty throws with undefined reserved property name.', function() {
|
|
var entity = new Entity();
|
|
expect(entity.name).toBeUndefined();
|
|
expect(function() {
|
|
entity.addProperty('name');
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('removeProperty throws with undefined reserved property name.', function() {
|
|
var entity = new Entity();
|
|
expect(entity.name).toBeUndefined();
|
|
expect(function() {
|
|
entity.removeProperty('name');
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('isShowing works without parent.', function() {
|
|
var entity = new Entity({
|
|
show : false
|
|
});
|
|
expect(entity.isShowing).toBe(false);
|
|
|
|
var listener = jasmine.createSpy('listener');
|
|
entity.definitionChanged.addEventListener(listener);
|
|
|
|
entity.show = true;
|
|
expect(listener.calls.count()).toBe(2);
|
|
expect(listener.calls.argsFor(0)).toEqual([entity, 'isShowing', true, false]);
|
|
expect(listener.calls.argsFor(1)).toEqual([entity, 'show', true, false]);
|
|
expect(entity.isShowing).toBe(true);
|
|
|
|
listener.calls.reset();
|
|
|
|
entity.show = false;
|
|
expect(listener.calls.count()).toBe(2);
|
|
expect(listener.calls.argsFor(0)).toEqual([entity, 'isShowing', false, true]);
|
|
expect(listener.calls.argsFor(1)).toEqual([entity, 'show', false, true]);
|
|
expect(entity.isShowing).toBe(false);
|
|
});
|
|
|
|
function ancestorShowTest(entity, ancestor) {
|
|
var listener = jasmine.createSpy('listener');
|
|
entity.definitionChanged.addEventListener(listener);
|
|
|
|
ancestor.show = false;
|
|
|
|
//Setting ancestor show to false causes entity to raise
|
|
//its own isShowing event, but not the show event.
|
|
expect(listener.calls.count()).toBe(1);
|
|
expect(listener.calls.argsFor(0)).toEqual([entity, 'isShowing', false, true]);
|
|
expect(entity.show).toBe(true);
|
|
expect(entity.isShowing).toBe(false);
|
|
|
|
listener.calls.reset();
|
|
|
|
//Since isShowing is already false, setting show to false causes the show event
|
|
//but not the isShowing event to be raised
|
|
entity.show = false;
|
|
expect(entity.show).toBe(false);
|
|
expect(listener.calls.count()).toBe(1);
|
|
expect(listener.calls.argsFor(0)).toEqual([entity, 'show', false, true]);
|
|
|
|
listener.calls.reset();
|
|
|
|
//Setting ancestor show to true does not trigger the entity.isShowing event
|
|
//because entity.show is false;
|
|
ancestor.show = true;
|
|
expect(entity.show).toBe(false);
|
|
expect(entity.isShowing).toBe(false);
|
|
expect(listener.calls.count()).toBe(0);
|
|
|
|
listener.calls.reset();
|
|
|
|
//Setting entity.show to try now causes both events to be raised
|
|
//because the ancestor is also showing.
|
|
entity.show = true;
|
|
expect(listener.calls.count()).toBe(2);
|
|
expect(listener.calls.argsFor(0)).toEqual([entity, 'isShowing', true, false]);
|
|
expect(listener.calls.argsFor(1)).toEqual([entity, 'show', true, false]);
|
|
expect(entity.show).toBe(true);
|
|
expect(entity.isShowing).toBe(true);
|
|
}
|
|
|
|
it('isShowing works with parent.', function() {
|
|
var parent = new Entity();
|
|
var entity = new Entity();
|
|
entity.parent = parent;
|
|
ancestorShowTest(entity, parent);
|
|
});
|
|
|
|
it('isShowing works with grandparent.', function() {
|
|
var grandparent = new Entity();
|
|
var parent = new Entity();
|
|
parent.parent = grandparent;
|
|
var entity = new Entity();
|
|
entity.parent = parent;
|
|
ancestorShowTest(entity, grandparent);
|
|
});
|
|
|
|
it('isShowing works when replacing parent.', function() {
|
|
var entity = new Entity();
|
|
entity.parent = new Entity();
|
|
|
|
var listener = jasmine.createSpy('listener');
|
|
entity.definitionChanged.addEventListener(listener);
|
|
|
|
entity.parent = new Entity({
|
|
show : false
|
|
});
|
|
|
|
expect(listener.calls.count()).toBe(2);
|
|
expect(listener.calls.argsFor(0)).toEqual([entity, 'isShowing', false, true]);
|
|
expect(entity.show).toBe(true);
|
|
expect(entity.isShowing).toBe(false);
|
|
});
|
|
|
|
it('isShowing works when removing parent.', function() {
|
|
var entity = new Entity();
|
|
entity.parent = new Entity({
|
|
show : false
|
|
});
|
|
expect(entity.isShowing).toBe(false);
|
|
|
|
var listener = jasmine.createSpy('listener');
|
|
entity.definitionChanged.addEventListener(listener);
|
|
|
|
entity.parent = undefined;
|
|
|
|
expect(listener.calls.count()).toBe(2);
|
|
expect(listener.calls.argsFor(0)).toEqual([entity, 'isShowing', true, false]);
|
|
expect(entity.isShowing).toBe(true);
|
|
});
|
|
});
|