You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1067 lines
38 KiB
JavaScript
1067 lines
38 KiB
JavaScript
import { Cartesian3 } from "../../Source/Cesium.js";
|
|
import { Cartographic } from "../../Source/Cesium.js";
|
|
import { Ellipsoid } from "../../Source/Cesium.js";
|
|
import { Math as CesiumMath } from "../../Source/Cesium.js";
|
|
import { Rectangle } from "../../Source/Cesium.js";
|
|
import createPackableSpecs from "../createPackableSpecs.js";
|
|
|
|
describe("Core/Rectangle", function () {
|
|
var west = -0.9;
|
|
var south = 0.5;
|
|
var east = 1.4;
|
|
var north = 1.0;
|
|
var center = new Cartographic((west + east) / 2.0, (south + north) / 2.0);
|
|
|
|
it("default constructor sets expected values.", function () {
|
|
var rectangle = new Rectangle();
|
|
expect(rectangle.west).toEqual(0.0);
|
|
expect(rectangle.south).toEqual(0.0);
|
|
expect(rectangle.north).toEqual(0.0);
|
|
expect(rectangle.east).toEqual(0.0);
|
|
});
|
|
|
|
it("constructor sets expected parameter values.", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
expect(rectangle.west).toEqual(west);
|
|
expect(rectangle.south).toEqual(south);
|
|
expect(rectangle.east).toEqual(east);
|
|
expect(rectangle.north).toEqual(north);
|
|
});
|
|
|
|
it("computeWidth", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var expected = east - west;
|
|
expect(Rectangle.computeWidth(rectangle)).toEqual(expected);
|
|
expect(rectangle.width).toEqual(expected);
|
|
|
|
rectangle = new Rectangle(2.0, -1.0, -2.0, 1.0);
|
|
expected = rectangle.east - rectangle.west + CesiumMath.TWO_PI;
|
|
expect(rectangle.width).toEqual(expected);
|
|
});
|
|
|
|
it("computeHeight", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var expected = north - south;
|
|
expect(Rectangle.computeHeight(rectangle)).toEqual(expected);
|
|
expect(rectangle.height).toEqual(expected);
|
|
});
|
|
|
|
it("fromDegrees produces expected values.", function () {
|
|
var west = -10.0;
|
|
var south = -20.0;
|
|
var east = 10.0;
|
|
var north = 20.0;
|
|
|
|
var rectangle = Rectangle.fromDegrees(west, south, east, north);
|
|
expect(rectangle.west).toEqual(CesiumMath.toRadians(west));
|
|
expect(rectangle.south).toEqual(CesiumMath.toRadians(south));
|
|
expect(rectangle.east).toEqual(CesiumMath.toRadians(east));
|
|
expect(rectangle.north).toEqual(CesiumMath.toRadians(north));
|
|
});
|
|
|
|
it("fromDegrees works with a result parameter.", function () {
|
|
var west = -10.0;
|
|
var south = -20.0;
|
|
var east = 10.0;
|
|
var north = 20.0;
|
|
|
|
var result = new Rectangle();
|
|
var rectangle = Rectangle.fromDegrees(west, south, east, north, result);
|
|
expect(result).toBe(rectangle);
|
|
expect(rectangle.west).toEqual(CesiumMath.toRadians(west));
|
|
expect(rectangle.south).toEqual(CesiumMath.toRadians(south));
|
|
expect(rectangle.east).toEqual(CesiumMath.toRadians(east));
|
|
expect(rectangle.north).toEqual(CesiumMath.toRadians(north));
|
|
});
|
|
|
|
it("fromRadians produces expected values.", function () {
|
|
var west = -1.0;
|
|
var south = -2.0;
|
|
var east = 1.0;
|
|
var north = 2.0;
|
|
|
|
var rectangle = Rectangle.fromRadians(west, south, east, north);
|
|
expect(rectangle.west).toEqual(west);
|
|
expect(rectangle.south).toEqual(south);
|
|
expect(rectangle.east).toEqual(east);
|
|
expect(rectangle.north).toEqual(north);
|
|
});
|
|
|
|
it("fromRadians works with a result parameter.", function () {
|
|
var west = -1.0;
|
|
var south = -2.0;
|
|
var east = 1.0;
|
|
var north = 2.0;
|
|
|
|
var result = new Rectangle();
|
|
var rectangle = Rectangle.fromRadians(west, south, east, north, result);
|
|
expect(result).toBe(rectangle);
|
|
expect(rectangle.west).toEqual(west);
|
|
expect(rectangle.south).toEqual(south);
|
|
expect(rectangle.east).toEqual(east);
|
|
expect(rectangle.north).toEqual(north);
|
|
});
|
|
|
|
it("fromCartographicArray produces expected values.", function () {
|
|
var minLon = new Cartographic(-0.1, 0.3, 0.0);
|
|
var minLat = new Cartographic(0.0, -0.2, 0.0);
|
|
var maxLon = new Cartographic(0.3, -0.1, 0.0);
|
|
var maxLat = new Cartographic(0.2, 0.4, 0.0);
|
|
|
|
var rectangle = Rectangle.fromCartographicArray([
|
|
minLat,
|
|
minLon,
|
|
maxLat,
|
|
maxLon,
|
|
]);
|
|
expect(rectangle.west).toEqual(minLon.longitude);
|
|
expect(rectangle.south).toEqual(minLat.latitude);
|
|
expect(rectangle.east).toEqual(maxLon.longitude);
|
|
expect(rectangle.north).toEqual(maxLat.latitude);
|
|
});
|
|
|
|
it("fromCartographicArray produces rectangle that crosses IDL.", function () {
|
|
var minLon = Cartographic.fromDegrees(-178, 3);
|
|
var minLat = Cartographic.fromDegrees(-179, -4);
|
|
var maxLon = Cartographic.fromDegrees(178, 3);
|
|
var maxLat = Cartographic.fromDegrees(179, 4);
|
|
|
|
var rectangle = Rectangle.fromCartographicArray([
|
|
minLat,
|
|
minLon,
|
|
maxLat,
|
|
maxLon,
|
|
]);
|
|
expect(rectangle.east).toEqual(minLon.longitude);
|
|
expect(rectangle.south).toEqual(minLat.latitude);
|
|
expect(rectangle.west).toEqual(maxLon.longitude);
|
|
expect(rectangle.north).toEqual(maxLat.latitude);
|
|
});
|
|
|
|
it("fromCartographicArray works with a result parameter.", function () {
|
|
var minLon = new Cartographic(-0.1, 0.3, 0.0);
|
|
var minLat = new Cartographic(0.0, -0.2, 0.0);
|
|
var maxLon = new Cartographic(0.3, -0.1, 0.0);
|
|
var maxLat = new Cartographic(0.2, 0.4, 0.0);
|
|
|
|
var result = new Rectangle();
|
|
var rectangle = Rectangle.fromCartographicArray(
|
|
[minLat, minLon, maxLat, maxLon],
|
|
result
|
|
);
|
|
expect(result).toBe(rectangle);
|
|
expect(rectangle.west).toEqual(minLon.longitude);
|
|
expect(rectangle.south).toEqual(minLat.latitude);
|
|
expect(rectangle.east).toEqual(maxLon.longitude);
|
|
expect(rectangle.north).toEqual(maxLat.latitude);
|
|
});
|
|
|
|
it("fromCartesianArray produces expected values.", function () {
|
|
var minLon = new Cartographic(-0.1, 0.3, 0.0);
|
|
var minLat = new Cartographic(0.0, -0.2, 0.0);
|
|
var maxLon = new Cartographic(0.3, -0.1, 0.0);
|
|
var maxLat = new Cartographic(0.2, 0.4, 0.0);
|
|
|
|
var wgs84 = Ellipsoid.WGS84;
|
|
|
|
var rectangle = Rectangle.fromCartesianArray(
|
|
wgs84.cartographicArrayToCartesianArray([minLat, minLon, maxLat, maxLon]),
|
|
wgs84
|
|
);
|
|
expect(rectangle.west).toEqualEpsilon(
|
|
minLon.longitude,
|
|
CesiumMath.EPSILON15
|
|
);
|
|
expect(rectangle.south).toEqualEpsilon(
|
|
minLat.latitude,
|
|
CesiumMath.EPSILON15
|
|
);
|
|
expect(rectangle.east).toEqualEpsilon(
|
|
maxLon.longitude,
|
|
CesiumMath.EPSILON15
|
|
);
|
|
expect(rectangle.north).toEqualEpsilon(
|
|
maxLat.latitude,
|
|
CesiumMath.EPSILON15
|
|
);
|
|
});
|
|
|
|
it("fromCartesianArray produces rectangle that crosses IDL.", function () {
|
|
var minLon = Cartographic.fromDegrees(-178, 3);
|
|
var minLat = Cartographic.fromDegrees(-179, -4);
|
|
var maxLon = Cartographic.fromDegrees(178, 3);
|
|
var maxLat = Cartographic.fromDegrees(179, 4);
|
|
|
|
var wgs84 = Ellipsoid.WGS84;
|
|
|
|
var rectangle = Rectangle.fromCartesianArray(
|
|
wgs84.cartographicArrayToCartesianArray([minLat, minLon, maxLat, maxLon]),
|
|
wgs84
|
|
);
|
|
expect(rectangle.east).toEqual(minLon.longitude);
|
|
expect(rectangle.south).toEqual(minLat.latitude);
|
|
expect(rectangle.west).toEqual(maxLon.longitude);
|
|
expect(rectangle.north).toEqual(maxLat.latitude);
|
|
});
|
|
|
|
it("fromCartesianArray works with a result parameter.", function () {
|
|
var minLon = new Cartographic(-0.1, 0.3, 0.0);
|
|
var minLat = new Cartographic(0.0, -0.2, 0.0);
|
|
var maxLon = new Cartographic(0.3, -0.1, 0.0);
|
|
var maxLat = new Cartographic(0.2, 0.4, 0.0);
|
|
|
|
var wgs84 = Ellipsoid.WGS84;
|
|
|
|
var result = new Rectangle();
|
|
var rectangle = Rectangle.fromCartesianArray(
|
|
wgs84.cartographicArrayToCartesianArray([minLat, minLon, maxLat, maxLon]),
|
|
wgs84,
|
|
result
|
|
);
|
|
expect(result).toBe(rectangle);
|
|
expect(rectangle.west).toEqualEpsilon(
|
|
minLon.longitude,
|
|
CesiumMath.EPSILON15
|
|
);
|
|
expect(rectangle.south).toEqualEpsilon(
|
|
minLat.latitude,
|
|
CesiumMath.EPSILON15
|
|
);
|
|
expect(rectangle.east).toEqualEpsilon(
|
|
maxLon.longitude,
|
|
CesiumMath.EPSILON15
|
|
);
|
|
expect(rectangle.north).toEqualEpsilon(
|
|
maxLat.latitude,
|
|
CesiumMath.EPSILON15
|
|
);
|
|
});
|
|
|
|
it("clone works without a result parameter.", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var returnedResult = rectangle.clone();
|
|
expect(returnedResult).toEqual(rectangle);
|
|
expect(returnedResult).not.toBe(rectangle);
|
|
});
|
|
|
|
it("clone works with a result parameter.", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var result = new Rectangle();
|
|
var returnedResult = rectangle.clone(result);
|
|
expect(returnedResult).toEqual(rectangle);
|
|
expect(returnedResult).not.toBe(rectangle);
|
|
expect(returnedResult).toBe(result);
|
|
});
|
|
|
|
it('clone works with "this" result parameter.', function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var returnedResult = rectangle.clone(rectangle);
|
|
expect(returnedResult).toEqual(new Rectangle(west, south, east, north));
|
|
expect(returnedResult).toBe(rectangle);
|
|
});
|
|
|
|
it("clone works without rectangle", function () {
|
|
expect(Rectangle.clone()).not.toBeDefined();
|
|
});
|
|
|
|
it("Equals works in all cases", function () {
|
|
var rectangle = new Rectangle(0.1, 0.2, 0.3, 0.4);
|
|
expect(rectangle.equals(new Rectangle(0.1, 0.2, 0.3, 0.4))).toEqual(true);
|
|
expect(rectangle.equals(new Rectangle(0.5, 0.2, 0.3, 0.4))).toEqual(false);
|
|
expect(rectangle.equals(new Rectangle(0.1, 0.5, 0.3, 0.4))).toEqual(false);
|
|
expect(rectangle.equals(new Rectangle(0.1, 0.2, 0.5, 0.4))).toEqual(false);
|
|
expect(rectangle.equals(new Rectangle(0.1, 0.2, 0.3, 0.5))).toEqual(false);
|
|
expect(rectangle.equals(undefined)).toEqual(false);
|
|
});
|
|
|
|
it("Static equals works in all cases", function () {
|
|
var rectangle = new Rectangle(0.1, 0.2, 0.3, 0.4);
|
|
expect(
|
|
Rectangle.equals(rectangle, new Rectangle(0.1, 0.2, 0.3, 0.4))
|
|
).toEqual(true);
|
|
expect(
|
|
Rectangle.equals(rectangle, new Rectangle(0.5, 0.2, 0.3, 0.4))
|
|
).toEqual(false);
|
|
expect(
|
|
Rectangle.equals(rectangle, new Rectangle(0.1, 0.5, 0.3, 0.4))
|
|
).toEqual(false);
|
|
expect(
|
|
Rectangle.equals(rectangle, new Rectangle(0.1, 0.2, 0.5, 0.4))
|
|
).toEqual(false);
|
|
expect(
|
|
Rectangle.equals(rectangle, new Rectangle(0.1, 0.2, 0.3, 0.5))
|
|
).toEqual(false);
|
|
expect(Rectangle.equals(rectangle, undefined)).toEqual(false);
|
|
});
|
|
|
|
it("Static equals epsilon works in all cases", function () {
|
|
var rectangle1 = new Rectangle(0.1, 0.2, 0.3, 0.4);
|
|
expect(
|
|
Rectangle.equalsEpsilon(
|
|
rectangle1,
|
|
new Rectangle(0.1, 0.2, 0.3, 0.4),
|
|
0.0
|
|
)
|
|
).toEqual(true);
|
|
expect(
|
|
Rectangle.equalsEpsilon(
|
|
rectangle1,
|
|
new Rectangle(0.5, 0.2, 0.3, 0.4),
|
|
0.0
|
|
)
|
|
).toEqual(false);
|
|
expect(
|
|
Rectangle.equalsEpsilon(
|
|
rectangle1,
|
|
new Rectangle(0.1, 0.5, 0.3, 0.4),
|
|
0.0
|
|
)
|
|
).toEqual(false);
|
|
expect(
|
|
Rectangle.equalsEpsilon(
|
|
rectangle1,
|
|
new Rectangle(0.1, 0.2, 0.5, 0.4),
|
|
0.0
|
|
)
|
|
).toEqual(false);
|
|
expect(
|
|
Rectangle.equalsEpsilon(
|
|
rectangle1,
|
|
new Rectangle(0.1, 0.2, 0.3, 0.5),
|
|
0.0
|
|
)
|
|
).toEqual(false);
|
|
expect(
|
|
Rectangle.equalsEpsilon(
|
|
rectangle1,
|
|
new Rectangle(0.5, 0.2, 0.3, 0.4),
|
|
0.4
|
|
)
|
|
).toEqual(true);
|
|
expect(
|
|
Rectangle.equalsEpsilon(
|
|
rectangle1,
|
|
new Rectangle(0.1, 0.5, 0.3, 0.4),
|
|
0.3
|
|
)
|
|
).toEqual(true);
|
|
expect(
|
|
Rectangle.equalsEpsilon(
|
|
rectangle1,
|
|
new Rectangle(0.1, 0.2, 0.5, 0.4),
|
|
0.2
|
|
)
|
|
).toEqual(true);
|
|
expect(
|
|
Rectangle.equalsEpsilon(
|
|
rectangle1,
|
|
new Rectangle(0.1, 0.2, 0.3, 0.5),
|
|
0.1
|
|
)
|
|
).toEqual(true);
|
|
expect(Rectangle.equalsEpsilon(rectangle1, undefined, 0.0)).toEqual(false);
|
|
expect(Rectangle.equalsEpsilon(undefined, rectangle1, 0.0)).toEqual(false);
|
|
expect(Rectangle.equalsEpsilon(rectangle1, rectangle1, 0.0)).toEqual(true);
|
|
});
|
|
|
|
it("Equals epsilon works in all cases", function () {
|
|
var rectangle = new Rectangle(0.1, 0.2, 0.3, 0.4);
|
|
expect(
|
|
rectangle.equalsEpsilon(new Rectangle(0.1, 0.2, 0.3, 0.4), 0.0)
|
|
).toEqual(true);
|
|
expect(
|
|
rectangle.equalsEpsilon(new Rectangle(0.5, 0.2, 0.3, 0.4), 0.0)
|
|
).toEqual(false);
|
|
expect(
|
|
rectangle.equalsEpsilon(new Rectangle(0.1, 0.5, 0.3, 0.4), 0.0)
|
|
).toEqual(false);
|
|
expect(
|
|
rectangle.equalsEpsilon(new Rectangle(0.1, 0.2, 0.5, 0.4), 0.0)
|
|
).toEqual(false);
|
|
expect(
|
|
rectangle.equalsEpsilon(new Rectangle(0.1, 0.2, 0.3, 0.5), 0.0)
|
|
).toEqual(false);
|
|
expect(
|
|
rectangle.equalsEpsilon(new Rectangle(0.5, 0.2, 0.3, 0.4), 0.4)
|
|
).toEqual(true);
|
|
expect(
|
|
rectangle.equalsEpsilon(new Rectangle(0.1, 0.5, 0.3, 0.4), 0.3)
|
|
).toEqual(true);
|
|
expect(
|
|
rectangle.equalsEpsilon(new Rectangle(0.1, 0.2, 0.5, 0.4), 0.2)
|
|
).toEqual(true);
|
|
expect(
|
|
rectangle.equalsEpsilon(new Rectangle(0.1, 0.2, 0.3, 0.5), 0.1)
|
|
).toEqual(true);
|
|
expect(rectangle.equalsEpsilon(undefined, 0.0)).toEqual(false);
|
|
});
|
|
|
|
it("fromCartographicArray throws with no array", function () {
|
|
expect(function () {
|
|
Rectangle.fromCartographicArray(undefined, new Rectangle());
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("fromCartesianArray throws with no array", function () {
|
|
expect(function () {
|
|
Rectangle.fromCartesianArray(undefined, undefined, new Rectangle());
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("validate throws with no rectangle", function () {
|
|
expect(function () {
|
|
Rectangle.validate();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("validate throws with no west", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
rectangle.west = undefined;
|
|
expect(function () {
|
|
Rectangle.validate(rectangle);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("validate throws with no south", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
rectangle.south = undefined;
|
|
expect(function () {
|
|
Rectangle.validate(rectangle);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("validate throws with no east", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
rectangle.east = undefined;
|
|
expect(function () {
|
|
Rectangle.validate(rectangle);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("validate throws with no north", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
rectangle.north = undefined;
|
|
expect(function () {
|
|
Rectangle.validate(rectangle);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("validate throws with bad west", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
rectangle.west = Math.PI * 2;
|
|
expect(function () {
|
|
Rectangle.validate(rectangle);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("validate throws with bad south", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
rectangle.south = Math.PI * 2;
|
|
expect(function () {
|
|
Rectangle.validate(rectangle);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("validate throws with bad east", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
rectangle.east = Math.PI * 2;
|
|
expect(function () {
|
|
Rectangle.validate(rectangle);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("validate throws with bad north", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
rectangle.north = Math.PI * 2;
|
|
expect(function () {
|
|
Rectangle.validate(rectangle);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("southwest works without a result parameter", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var returnedResult = Rectangle.southwest(rectangle);
|
|
expect(returnedResult.longitude).toEqual(west);
|
|
expect(returnedResult.latitude).toEqual(south);
|
|
});
|
|
|
|
it("southwest works with a result parameter", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var result = new Cartographic();
|
|
var returnedResult = Rectangle.southwest(rectangle, result);
|
|
expect(returnedResult).toBe(result);
|
|
expect(returnedResult.longitude).toEqual(west);
|
|
expect(returnedResult.latitude).toEqual(south);
|
|
});
|
|
|
|
it("southwest throws with no rectangle", function () {
|
|
expect(function () {
|
|
Rectangle.southwest();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("northwest works without a result parameter", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var returnedResult = Rectangle.northwest(rectangle);
|
|
expect(returnedResult.longitude).toEqual(west);
|
|
expect(returnedResult.latitude).toEqual(north);
|
|
});
|
|
|
|
it("northwest works with a result parameter", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var result = new Cartographic();
|
|
var returnedResult = Rectangle.northwest(rectangle, result);
|
|
expect(returnedResult).toBe(result);
|
|
expect(returnedResult.longitude).toEqual(west);
|
|
expect(returnedResult.latitude).toEqual(north);
|
|
});
|
|
|
|
it("getNothwest throws with no rectangle", function () {
|
|
expect(function () {
|
|
Rectangle.northwest();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("northeast works without a result parameter", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var returnedResult = Rectangle.northeast(rectangle);
|
|
expect(returnedResult.longitude).toEqual(east);
|
|
expect(returnedResult.latitude).toEqual(north);
|
|
});
|
|
|
|
it("northeast works with a result parameter", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var result = new Cartographic();
|
|
var returnedResult = Rectangle.northeast(rectangle, result);
|
|
expect(returnedResult).toBe(result);
|
|
expect(returnedResult.longitude).toEqual(east);
|
|
expect(returnedResult.latitude).toEqual(north);
|
|
});
|
|
|
|
it("getNotheast throws with no rectangle", function () {
|
|
expect(function () {
|
|
Rectangle.northeast();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("southeast works without a result parameter", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var returnedResult = Rectangle.southeast(rectangle);
|
|
expect(returnedResult.longitude).toEqual(east);
|
|
expect(returnedResult.latitude).toEqual(south);
|
|
});
|
|
|
|
it("southeast works with a result parameter", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var result = new Cartographic();
|
|
var returnedResult = Rectangle.southeast(rectangle, result);
|
|
expect(returnedResult).toBe(result);
|
|
expect(returnedResult.longitude).toEqual(east);
|
|
expect(returnedResult.latitude).toEqual(south);
|
|
});
|
|
|
|
it("southeast throws with no rectangle", function () {
|
|
expect(function () {
|
|
Rectangle.southeast();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("center works without a result parameter", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var returnedResult = Rectangle.center(rectangle);
|
|
expect(returnedResult).toEqualEpsilon(center, CesiumMath.EPSILON11);
|
|
});
|
|
|
|
it("center works with a result parameter", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var result = new Cartographic();
|
|
var returnedResult = Rectangle.center(rectangle, result);
|
|
expect(result).toBe(returnedResult);
|
|
expect(returnedResult).toEqualEpsilon(center, CesiumMath.EPSILON11);
|
|
});
|
|
|
|
it("center works across IDL", function () {
|
|
var rectangle = Rectangle.fromDegrees(170, 0, -170, 0);
|
|
var returnedResult = Rectangle.center(rectangle);
|
|
expect(returnedResult).toEqualEpsilon(
|
|
Cartographic.fromDegrees(180, 0),
|
|
CesiumMath.EPSILON11
|
|
);
|
|
|
|
rectangle = Rectangle.fromDegrees(160, 0, -170, 0);
|
|
returnedResult = Rectangle.center(rectangle);
|
|
expect(returnedResult).toEqualEpsilon(
|
|
Cartographic.fromDegrees(175, 0),
|
|
CesiumMath.EPSILON11
|
|
);
|
|
|
|
rectangle = Rectangle.fromDegrees(170, 0, -160, 0);
|
|
returnedResult = Rectangle.center(rectangle);
|
|
expect(returnedResult).toEqualEpsilon(
|
|
Cartographic.fromDegrees(-175, 0),
|
|
CesiumMath.EPSILON11
|
|
);
|
|
|
|
rectangle = Rectangle.fromDegrees(160, 0, 140, 0);
|
|
returnedResult = Rectangle.center(rectangle);
|
|
expect(returnedResult).toEqualEpsilon(
|
|
Cartographic.fromDegrees(-30, 0),
|
|
CesiumMath.EPSILON11
|
|
);
|
|
});
|
|
|
|
it("center throws with no rectangle", function () {
|
|
expect(function () {
|
|
Rectangle.center();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("intersection works without a result parameter", function () {
|
|
var rectangle = new Rectangle(0.5, 0.1, 0.75, 0.9);
|
|
var rectangle2 = new Rectangle(0.0, 0.25, 1.0, 0.8);
|
|
var expected = new Rectangle(0.5, 0.25, 0.75, 0.8);
|
|
var returnedResult = Rectangle.intersection(rectangle, rectangle2);
|
|
expect(returnedResult).toEqual(expected);
|
|
});
|
|
|
|
it("intersection works with a result parameter", function () {
|
|
var rectangle = new Rectangle(0.5, 0.1, 0.75, 0.9);
|
|
var rectangle2 = new Rectangle(0.0, 0.25, 1.0, 0.8);
|
|
var expected = new Rectangle(0.5, 0.25, 0.75, 0.8);
|
|
var result = new Rectangle();
|
|
var returnedResult = Rectangle.intersection(rectangle, rectangle2, result);
|
|
expect(returnedResult).toEqual(expected);
|
|
expect(result).toBe(returnedResult);
|
|
});
|
|
|
|
it("intersection works across the IDL (1)", function () {
|
|
var rectangle1 = Rectangle.fromDegrees(170.0, -10.0, -170.0, 10.0);
|
|
var rectangle2 = Rectangle.fromDegrees(-175.0, 5.0, -160.0, 15.0);
|
|
var expected = Rectangle.fromDegrees(-175.0, 5.0, -170.0, 10.0);
|
|
expect(Rectangle.intersection(rectangle1, rectangle2)).toEqual(expected);
|
|
expect(Rectangle.intersection(rectangle2, rectangle1)).toEqual(expected);
|
|
});
|
|
|
|
it("intersection works across the IDL (2)", function () {
|
|
var rectangle1 = Rectangle.fromDegrees(170.0, -10.0, -170.0, 10.0);
|
|
var rectangle2 = Rectangle.fromDegrees(160.0, 5.0, 175.0, 15.0);
|
|
var expected = Rectangle.fromDegrees(170.0, 5.0, 175.0, 10.0);
|
|
expect(Rectangle.intersection(rectangle1, rectangle2)).toEqual(expected);
|
|
expect(Rectangle.intersection(rectangle2, rectangle1)).toEqual(expected);
|
|
});
|
|
|
|
it("intersection works across the IDL (3)", function () {
|
|
var rectangle1 = Rectangle.fromDegrees(170.0, -10.0, -170.0, 10.0);
|
|
var rectangle2 = Rectangle.fromDegrees(175.0, 5.0, -175.0, 15.0);
|
|
var expected = Rectangle.fromDegrees(175.0, 5.0, -175.0, 10.0);
|
|
expect(Rectangle.intersection(rectangle1, rectangle2)).toEqual(expected);
|
|
expect(Rectangle.intersection(rectangle2, rectangle1)).toEqual(expected);
|
|
});
|
|
|
|
it("intersection returns undefined for a point", function () {
|
|
var rectangle1 = new Rectangle(west, south, east, north);
|
|
var rectangle2 = new Rectangle(east, north, east + 0.1, north + 0.1);
|
|
expect(Rectangle.intersection(rectangle1, rectangle2)).not.toBeDefined();
|
|
expect(Rectangle.intersection(rectangle2, rectangle1)).not.toBeDefined();
|
|
});
|
|
|
|
it("intersection returns undefined for a east-west line (1)", function () {
|
|
var rectangle1 = new Rectangle(west, south, east, north);
|
|
var rectangle2 = new Rectangle(west, north, east, north + 0.1);
|
|
expect(Rectangle.intersection(rectangle1, rectangle2)).not.toBeDefined();
|
|
expect(Rectangle.intersection(rectangle2, rectangle1)).not.toBeDefined();
|
|
});
|
|
|
|
it("intersection returns undefined for a east-west line (2)", function () {
|
|
var rectangle1 = new Rectangle(west, south, east, north);
|
|
var rectangle2 = new Rectangle(west, south + 0.1, east, south);
|
|
expect(Rectangle.intersection(rectangle1, rectangle2)).not.toBeDefined();
|
|
expect(Rectangle.intersection(rectangle2, rectangle1)).not.toBeDefined();
|
|
});
|
|
|
|
it("intersection returns undefined for a north-south line (1)", function () {
|
|
var rectangle1 = new Rectangle(west, south, east, north);
|
|
var rectangle2 = new Rectangle(east, south, east + 0.1, north);
|
|
expect(Rectangle.intersection(rectangle1, rectangle2)).not.toBeDefined();
|
|
expect(Rectangle.intersection(rectangle2, rectangle1)).not.toBeDefined();
|
|
});
|
|
|
|
it("intersection returns undefined for a north-south line (2)", function () {
|
|
var rectangle1 = new Rectangle(west, south, east, north);
|
|
var rectangle2 = new Rectangle(west - 0.1, south, west, north);
|
|
expect(Rectangle.intersection(rectangle1, rectangle2)).not.toBeDefined();
|
|
expect(Rectangle.intersection(rectangle2, rectangle1)).not.toBeDefined();
|
|
});
|
|
|
|
it("intersection returns undefined for a north-south line (3)", function () {
|
|
var west = CesiumMath.toRadians(170.0);
|
|
var south = CesiumMath.toRadians(-10.0);
|
|
var east = CesiumMath.toRadians(-170.0);
|
|
var north = CesiumMath.toRadians(10.0);
|
|
|
|
var rectangle1 = new Rectangle(west, south, east, north);
|
|
var rectangle2 = new Rectangle(east, south, east + 0.1, north);
|
|
expect(Rectangle.intersection(rectangle1, rectangle2)).not.toBeDefined();
|
|
expect(Rectangle.intersection(rectangle2, rectangle1)).not.toBeDefined();
|
|
});
|
|
|
|
it("intersection returns undefined for a north-south line (4)", function () {
|
|
var west = CesiumMath.toRadians(170.0);
|
|
var south = CesiumMath.toRadians(-10.0);
|
|
var east = CesiumMath.toRadians(-170.0);
|
|
var north = CesiumMath.toRadians(10.0);
|
|
|
|
var rectangle1 = new Rectangle(west, south, east, north);
|
|
var rectangle2 = new Rectangle(west - 0.1, south, west, north);
|
|
expect(Rectangle.intersection(rectangle1, rectangle2)).not.toBeDefined();
|
|
expect(Rectangle.intersection(rectangle2, rectangle1)).not.toBeDefined();
|
|
});
|
|
|
|
it("intersection returns undefined if north-south direction is degenerate", function () {
|
|
var rectangle1 = new Rectangle(west, south, east, north);
|
|
var rectangle2 = new Rectangle(west, north + 0.1, east, north + 0.2);
|
|
expect(Rectangle.intersection(rectangle1, rectangle2)).not.toBeDefined();
|
|
expect(Rectangle.intersection(rectangle2, rectangle1)).not.toBeDefined();
|
|
});
|
|
|
|
it("intersection returns undefined if east-west direction is degenerate", function () {
|
|
var rectangle1 = new Rectangle(west, south, east, north);
|
|
var rectangle2 = new Rectangle(east + 0.1, south, east + 0.2, north);
|
|
expect(Rectangle.intersection(rectangle1, rectangle2)).not.toBeDefined();
|
|
expect(Rectangle.intersection(rectangle2, rectangle1)).not.toBeDefined();
|
|
});
|
|
|
|
it("union works without a result parameter", function () {
|
|
var rectangle1 = new Rectangle(0.5, 0.1, 0.75, 0.9);
|
|
var rectangle2 = new Rectangle(0.4, 0.0, 0.85, 0.8);
|
|
var expected = new Rectangle(0.4, 0.0, 0.85, 0.9);
|
|
var returnedResult = Rectangle.union(rectangle1, rectangle2);
|
|
expect(returnedResult).toEqual(expected);
|
|
});
|
|
|
|
it("union works with a result parameter", function () {
|
|
var rectangle1 = new Rectangle(0.5, 0.1, 0.75, 0.9);
|
|
var rectangle2 = new Rectangle(0.4, 0.0, 0.85, 0.8);
|
|
var expected = new Rectangle(0.4, 0.0, 0.85, 0.9);
|
|
var result = new Rectangle(-1.0, -1.0, 10.0, 10.0);
|
|
var returnedResult = Rectangle.union(rectangle1, rectangle2, result);
|
|
expect(result).toBe(returnedResult);
|
|
expect(returnedResult).toEqual(expected);
|
|
});
|
|
|
|
it("union works with first rectangle crossing the IDL", function () {
|
|
var rectangle1 = new Rectangle(0.5, 0.1, -0.5, 0.9);
|
|
var rectangle2 = new Rectangle(-0.85, 0.0, -0.4, 0.8);
|
|
var expected = new Rectangle(0.5, 0.0, -0.4, 0.9);
|
|
var returnedResult = Rectangle.union(rectangle1, rectangle2);
|
|
expect(returnedResult).toEqualEpsilon(expected, CesiumMath.EPSILON15);
|
|
});
|
|
|
|
it("union works with second rectangle crossing the IDL", function () {
|
|
var rectangle1 = new Rectangle(0.5, 0.1, 0.75, 0.9);
|
|
var rectangle2 = new Rectangle(0.6, 0.0, -0.2, 0.8);
|
|
var expected = new Rectangle(0.5, 0.0, -0.2, 0.9);
|
|
var returnedResult = Rectangle.union(rectangle1, rectangle2);
|
|
expect(returnedResult).toEqualEpsilon(expected, CesiumMath.EPSILON15);
|
|
});
|
|
|
|
it("union works with both rectangles crossing the IDL", function () {
|
|
var rectangle1 = new Rectangle(0.5, 0.1, -0.4, 0.9);
|
|
var rectangle2 = new Rectangle(0.4, 0.0, -0.5, 0.8);
|
|
var expected = new Rectangle(0.4, 0.0, -0.4, 0.9);
|
|
var returnedResult = Rectangle.union(rectangle1, rectangle2);
|
|
expect(returnedResult).toEqualEpsilon(expected, CesiumMath.EPSILON15);
|
|
});
|
|
|
|
it("expand works if rectangle needs to grow right", function () {
|
|
var rectangle = new Rectangle(0.5, 0.1, 0.75, 0.9);
|
|
var cartographic = new Cartographic(0.85, 0.5);
|
|
var expected = new Rectangle(0.5, 0.1, 0.85, 0.9);
|
|
var result = Rectangle.expand(rectangle, cartographic);
|
|
expect(result).toEqual(expected);
|
|
});
|
|
|
|
it("expand works if rectangle needs to grow left", function () {
|
|
var rectangle = new Rectangle(0.5, 0.1, 0.75, 0.9);
|
|
var cartographic = new Cartographic(0.4, 0.5);
|
|
var expected = new Rectangle(0.4, 0.1, 0.75, 0.9);
|
|
var result = Rectangle.expand(rectangle, cartographic);
|
|
expect(result).toEqual(expected);
|
|
});
|
|
|
|
it("expand works if rectangle needs to grow up", function () {
|
|
var rectangle = new Rectangle(0.5, 0.1, 0.75, 0.9);
|
|
var cartographic = new Cartographic(0.6, 1.0);
|
|
var expected = new Rectangle(0.5, 0.1, 0.75, 1.0);
|
|
var result = Rectangle.expand(rectangle, cartographic);
|
|
expect(result).toEqual(expected);
|
|
});
|
|
|
|
it("expand works if rectangle needs to grow down", function () {
|
|
var rectangle = new Rectangle(0.5, 0.1, 0.75, 0.9);
|
|
var cartographic = new Cartographic(0.6, 0.0);
|
|
var expected = new Rectangle(0.5, 0.0, 0.75, 0.9);
|
|
var result = Rectangle.expand(rectangle, cartographic);
|
|
expect(result).toEqual(expected);
|
|
});
|
|
|
|
it("expand works if rectangle does not need to grow", function () {
|
|
var rectangle = new Rectangle(0.5, 0.1, 0.75, 0.9);
|
|
var cartographic = new Cartographic(0.6, 0.5);
|
|
var expected = new Rectangle(0.5, 0.1, 0.75, 0.9);
|
|
var result = Rectangle.expand(rectangle, cartographic);
|
|
expect(result).toEqual(expected);
|
|
});
|
|
|
|
it("expand works with a result parameter", function () {
|
|
var rectangle = new Rectangle(0.5, 0.1, 0.75, 0.9);
|
|
var cartographic = new Cartographic(0.85, 1.0);
|
|
var expected = new Rectangle(0.5, 0.1, 0.85, 1.0);
|
|
var result = new Rectangle();
|
|
var returnedResult = Rectangle.expand(rectangle, cartographic, result);
|
|
expect(returnedResult).toBe(returnedResult);
|
|
expect(result).toEqual(expected);
|
|
});
|
|
|
|
it("contains works", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(west, south))
|
|
).toEqual(true);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(west, north))
|
|
).toEqual(true);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(east, south))
|
|
).toEqual(true);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(east, north))
|
|
).toEqual(true);
|
|
expect(Rectangle.contains(rectangle, Rectangle.center(rectangle))).toEqual(
|
|
true
|
|
);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(west - 0.1, south))
|
|
).toEqual(false);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(west, north + 0.1))
|
|
).toEqual(false);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(east, south - 0.1))
|
|
).toEqual(false);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(east + 0.1, north))
|
|
).toEqual(false);
|
|
});
|
|
|
|
it("contains works with rectangle across the IDL", function () {
|
|
var west = CesiumMath.toRadians(170.0);
|
|
var south = CesiumMath.toRadians(-10.0);
|
|
var east = CesiumMath.toRadians(-170.0);
|
|
var north = CesiumMath.toRadians(10.0);
|
|
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(west, south))
|
|
).toEqual(true);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(west, north))
|
|
).toEqual(true);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(east, south))
|
|
).toEqual(true);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(east, north))
|
|
).toEqual(true);
|
|
expect(Rectangle.contains(rectangle, Rectangle.center(rectangle))).toEqual(
|
|
true
|
|
);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(west - 0.1, south))
|
|
).toEqual(false);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(west, north + 0.1))
|
|
).toEqual(false);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(east, south - 0.1))
|
|
).toEqual(false);
|
|
expect(
|
|
Rectangle.contains(rectangle, new Cartographic(east + 0.1, north))
|
|
).toEqual(false);
|
|
});
|
|
|
|
it("subsample works south of the equator", function () {
|
|
var west = 0.1;
|
|
var south = -0.3;
|
|
var east = 0.2;
|
|
var north = -0.4;
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var returnedResult = Rectangle.subsample(rectangle);
|
|
expect(returnedResult).toEqual([
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.northwest(rectangle)),
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.northeast(rectangle)),
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.southeast(rectangle)),
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.southwest(rectangle)),
|
|
]);
|
|
});
|
|
|
|
it("subsample works with a result parameter", function () {
|
|
var west = 0.1;
|
|
var south = -0.3;
|
|
var east = 0.2;
|
|
var north = -0.4;
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var cartesian0 = new Cartesian3();
|
|
var results = [cartesian0];
|
|
var returnedResult = Rectangle.subsample(
|
|
rectangle,
|
|
Ellipsoid.WGS84,
|
|
0.0,
|
|
results
|
|
);
|
|
expect(results).toBe(returnedResult);
|
|
expect(results[0]).toBe(cartesian0);
|
|
expect(returnedResult).toEqual([
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.northwest(rectangle)),
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.northeast(rectangle)),
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.southeast(rectangle)),
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.southwest(rectangle)),
|
|
]);
|
|
});
|
|
|
|
it("subsample works north of the equator", function () {
|
|
var west = 0.1;
|
|
var south = 0.3;
|
|
var east = 0.2;
|
|
var north = 0.4;
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var returnedResult = Rectangle.subsample(rectangle);
|
|
expect(returnedResult).toEqual([
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.northwest(rectangle)),
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.northeast(rectangle)),
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.southeast(rectangle)),
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.southwest(rectangle)),
|
|
]);
|
|
});
|
|
|
|
it("subsample works on the equator", function () {
|
|
var west = 0.1;
|
|
var south = -0.1;
|
|
var east = 0.2;
|
|
var north = 0.0;
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var returnedResult = Rectangle.subsample(rectangle);
|
|
expect(returnedResult.length).toEqual(6);
|
|
expect(returnedResult[0]).toEqual(
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.northwest(rectangle))
|
|
);
|
|
expect(returnedResult[1]).toEqual(
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.northeast(rectangle))
|
|
);
|
|
expect(returnedResult[2]).toEqual(
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.southeast(rectangle))
|
|
);
|
|
expect(returnedResult[3]).toEqual(
|
|
Ellipsoid.WGS84.cartographicToCartesian(Rectangle.southwest(rectangle))
|
|
);
|
|
|
|
var cartographic4 = Ellipsoid.WGS84.cartesianToCartographic(
|
|
returnedResult[4]
|
|
);
|
|
expect(cartographic4.latitude).toEqual(0.0);
|
|
expect(cartographic4.longitude).toEqualEpsilon(west, CesiumMath.EPSILON16);
|
|
|
|
var cartographic5 = Ellipsoid.WGS84.cartesianToCartographic(
|
|
returnedResult[5]
|
|
);
|
|
expect(cartographic5.latitude).toEqual(0.0);
|
|
expect(cartographic5.longitude).toEqualEpsilon(east, CesiumMath.EPSILON16);
|
|
});
|
|
|
|
it("subsample works at a height above the ellipsoid", function () {
|
|
var west = 0.1;
|
|
var south = -0.3;
|
|
var east = 0.2;
|
|
var north = -0.4;
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var height = 100000.0;
|
|
var returnedResult = Rectangle.subsample(
|
|
rectangle,
|
|
Ellipsoid.WGS84,
|
|
height
|
|
);
|
|
|
|
var nw = Rectangle.northwest(rectangle);
|
|
nw.height = height;
|
|
var ne = Rectangle.northeast(rectangle);
|
|
ne.height = height;
|
|
var se = Rectangle.southeast(rectangle);
|
|
se.height = height;
|
|
var sw = Rectangle.southwest(rectangle);
|
|
sw.height = height;
|
|
|
|
expect(returnedResult).toEqual([
|
|
Ellipsoid.WGS84.cartographicToCartesian(nw),
|
|
Ellipsoid.WGS84.cartographicToCartesian(ne),
|
|
Ellipsoid.WGS84.cartographicToCartesian(se),
|
|
Ellipsoid.WGS84.cartographicToCartesian(sw),
|
|
]);
|
|
});
|
|
|
|
it("subsample throws with no rectangle", function () {
|
|
expect(function () {
|
|
Rectangle.subsample();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("intersection throws with no rectangle", function () {
|
|
expect(function () {
|
|
Rectangle.intersection(undefined);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("intersection throws with no otherRectangle", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
expect(function () {
|
|
Rectangle.intersection(rectangle, undefined);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("union throws with no rectangle", function () {
|
|
expect(function () {
|
|
Rectangle.union(undefined);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("union throws with no otherRectangle", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
expect(function () {
|
|
Rectangle.intersection(rectangle, undefined);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("expand throws with no rectangle", function () {
|
|
expect(function () {
|
|
Rectangle.expand(undefined);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("expand throws with no cartographic", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
expect(function () {
|
|
Rectangle.expand(rectangle, undefined);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it("contains throws with no cartographic", function () {
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
expect(function () {
|
|
Rectangle.contains(rectangle, undefined);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var packedInstance = [west, south, east, north];
|
|
createPackableSpecs(Rectangle, rectangle, packedInstance);
|
|
});
|