remove the old tests
This commit is contained in:
Éric Lemoine
@@ -1,69 +0,0 @@
|
||||
describe("ol.Bounds", function() {
|
||||
|
||||
describe("creating a bounds", function() {
|
||||
it("creates a bounds instance", function() {
|
||||
var bounds = new ol.Bounds(1, 2, 3, 4);
|
||||
expect(bounds).toBeA(ol.Bounds);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getting properties", function() {
|
||||
var bounds = new ol.Bounds(10, 20, 30, 50);
|
||||
|
||||
it("allows getting width", function() {
|
||||
expect(bounds.getWidth()).toBe(20);
|
||||
});
|
||||
|
||||
it("allows getting height", function() {
|
||||
expect(bounds.getHeight()).toBe(30);
|
||||
});
|
||||
|
||||
it("allows getting null projection", function() {
|
||||
expect(bounds.getProjection()).toBeNull();
|
||||
});
|
||||
|
||||
it("allws getting a projection", function() {
|
||||
var proj = new ol.Projection("EPSG:4326");
|
||||
var bounds = new ol.Bounds(-180, -90, 180, 90, proj);
|
||||
expect(bounds.getProjection()).toBe(proj);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe("transforming bounds", function() {
|
||||
|
||||
var gg = new ol.Projection("EPSG:4326");
|
||||
var sm = new ol.Projection("EPSG:900913");
|
||||
|
||||
var bounds = new ol.Bounds(10, -10, 20, 10, gg);
|
||||
|
||||
// approximate bbox array
|
||||
function bbox(bounds) {
|
||||
var mult = Math.pow(10, 6); // six figs
|
||||
return [
|
||||
Math.round(bounds.getMinX() * mult) / mult,
|
||||
Math.round(bounds.getMinY() * mult) / mult,
|
||||
Math.round(bounds.getMaxX() * mult) / mult,
|
||||
Math.round(bounds.getMaxY() * mult) / mult
|
||||
];
|
||||
}
|
||||
|
||||
it("doesn't mind a null transform", function() {
|
||||
var trans = bounds.transform(new ol.Projection("foo"));
|
||||
expect(bbox(bounds)).toEqual([10, -10, 20, 10]);
|
||||
});
|
||||
|
||||
it("transforms from geographic to spherical mercator", function() {
|
||||
var trans = bounds.transform(sm);
|
||||
expect(bbox(trans)).toEqual([1113194.907778, -1118889.974702, 2226389.815556, 1118889.974702]);
|
||||
});
|
||||
|
||||
it("transforms from spherical mercator to geographic", function() {
|
||||
var trans = bounds.transform(sm);
|
||||
var back = trans.transform(gg);
|
||||
expect(bbox(back)).toEqual([10, -10, 20, 10]);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
});
|
||||
@@ -1,79 +0,0 @@
|
||||
describe("ol.Feature", function() {
|
||||
|
||||
it("should be easy to make a feature", function() {
|
||||
var feat = new ol.Feature();
|
||||
|
||||
expect(feat).toBeA(ol.Feature);
|
||||
});
|
||||
|
||||
it("should be easy to set feature attribute", function() {
|
||||
|
||||
var feat = new ol.Feature();
|
||||
feat.setAttribute('foo', 'bar');
|
||||
|
||||
expect(feat).toBeA(ol.Feature);
|
||||
expect(feat.getAttribute('foo')).toBe('bar');
|
||||
});
|
||||
|
||||
it("calling set with one argument", function() {
|
||||
|
||||
var feat = new ol.Feature();
|
||||
feat.setAttribute('foo');
|
||||
|
||||
expect(feat.getAttribute('foo')).toBe(undefined);
|
||||
});
|
||||
|
||||
it("should be easy to set feature geometry", function() {
|
||||
|
||||
var feat = new ol.Feature();
|
||||
var point = ol.geom.point([21, 4]);
|
||||
feat.setGeometry(point);
|
||||
|
||||
var geom = feat.getGeometry();
|
||||
expect(feat).toBeA(ol.Feature);
|
||||
expect(geom).toBeA(ol.geom.Geometry);
|
||||
expect(geom.getX()).toBe(21);
|
||||
expect(geom.getY()).toBe(4);
|
||||
});
|
||||
|
||||
it("should be able to set attributes from object literals", function() {
|
||||
|
||||
var feat = new ol.Feature();
|
||||
feat.setAttributes({
|
||||
foo: 'bar',
|
||||
two: 'deux',
|
||||
size: 3,
|
||||
flag: true
|
||||
});
|
||||
|
||||
expect(feat).toBeA(ol.Feature);
|
||||
expect(feat.getAttribute('foo')).toBe('bar');
|
||||
expect(feat.getAttribute('two')).toBe('deux');
|
||||
expect(feat.getAttribute('size')).toBe(3);
|
||||
expect(feat.getAttribute('flag')).toBe(true);
|
||||
});
|
||||
|
||||
it("should be able to set attributes keeping existing ones", function() {
|
||||
|
||||
var feat = new ol.Feature();
|
||||
feat.setAttributes({
|
||||
foo: 'bar',
|
||||
size: 3
|
||||
});
|
||||
|
||||
expect(feat).toBeA(ol.Feature);
|
||||
expect(feat.getAttribute('size')).toBe(3);
|
||||
|
||||
feat.setAttributes({
|
||||
two: 'deux',
|
||||
size: -99
|
||||
});
|
||||
|
||||
expect(feat.getAttribute('two')).toBe('deux');
|
||||
expect(feat.getAttribute('foo')).toBe('bar');
|
||||
expect(feat.getAttribute('size')).toBe(-99);
|
||||
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
@@ -1,30 +0,0 @@
|
||||
describe('ol.Loc', function() {
|
||||
|
||||
it("should be easy to get a new location with deltas added to coordinates", function() {
|
||||
var loc, newLoc;
|
||||
|
||||
loc = new ol.Loc(1, 2, 3);
|
||||
newLoc = loc.add(1, 2, 3);
|
||||
expect(newLoc.getX()).toBe(2);
|
||||
expect(newLoc.getY()).toBe(4);
|
||||
expect(newLoc.getZ()).toBe(6);
|
||||
|
||||
loc = new ol.Loc(1, 2);
|
||||
newLoc =loc.add(1, 2);
|
||||
expect(newLoc.getX()).toBe(2);
|
||||
expect(newLoc.getY()).toBe(4);
|
||||
expect(newLoc.getZ()).toBeUndefined();
|
||||
|
||||
newLoc = loc.add(0, 0, 1);
|
||||
expect(newLoc.getZ()).toBeUndefined();
|
||||
});
|
||||
|
||||
it("should be immutable", function() {
|
||||
var loc = new ol.Loc(1, 2, 3);
|
||||
loc.add(1, 2, 3);
|
||||
expect(loc.getX()).toBe(1);
|
||||
expect(loc.getY()).toBe(2);
|
||||
expect(loc.getZ()).toBe(3);
|
||||
});
|
||||
|
||||
});
|
||||
@@ -1,96 +0,0 @@
|
||||
describe("ol.Popup", function() {
|
||||
|
||||
it("should be able to add it to a map", function() {
|
||||
|
||||
var map = new ol.Map();
|
||||
var popup = new ol.Popup(map);
|
||||
|
||||
expect(popup).toBeA(ol.Popup);
|
||||
expect(popup.getMap()).toBeA(ol.Map);
|
||||
});
|
||||
|
||||
it("should be able to place it at a specific location", function() {
|
||||
|
||||
var map = new ol.Map();
|
||||
var popup = new ol.Popup(map, new ol.Loc(10,20));
|
||||
|
||||
expect(popup).toBeA(ol.Popup);
|
||||
expect(popup.getAnchor()).toBeA(ol.Loc);
|
||||
expect(popup.getAnchor().x()).toBe(10);
|
||||
expect(popup.getAnchor().y()).toBe(20);
|
||||
});
|
||||
|
||||
it("should be able to anchor it with a feature", function() {
|
||||
|
||||
var feat = new ol.Feature();
|
||||
feat.setGeometry(new ol.geom.Point(21, 4));
|
||||
var map = new ol.Map();
|
||||
var popup = new ol.Popup(map, feat);
|
||||
|
||||
expect(popup).toBeA(ol.Popup);
|
||||
var anchor = popup.getAnchor();
|
||||
expect(anchor).toBeA(ol.Feature);
|
||||
var geom = anchor.getGeometry();
|
||||
expect(geom.getX()).toBe(21);
|
||||
expect(geom.getY()).toBe(4);
|
||||
});
|
||||
|
||||
/*
|
||||
it("should be able to set the placement top of the location", function() {
|
||||
|
||||
var map = new ol.Map();
|
||||
var popup = new ol.Popup(map, new ol.Loc(10,20),'top');
|
||||
|
||||
expect(popup).toBeA(ol.Popup);
|
||||
popup.open();
|
||||
var elems = goog.dom.getElementsByClass('ol-popup-top');
|
||||
expect(elems.length).toBe(1);
|
||||
elems = goog.dom.getElementsByClass('ol-popup-close');
|
||||
expect(elems.length).toBe(1);
|
||||
popup.close();
|
||||
});
|
||||
|
||||
it("should be able to change the placement", function() {
|
||||
|
||||
var map = new ol.Map();
|
||||
var popup = new ol.Popup(map, new ol.Loc(10,20),'top',false);
|
||||
|
||||
expect(popup).toBeA(ol.Popup);
|
||||
popup.open();
|
||||
var elems = goog.dom.getElementsByClass('ol-popup-top');
|
||||
expect(elems.length).toBe(1);
|
||||
elems = goog.dom.getElementsByClass('ol-popup-close');
|
||||
expect(elems.length).toBe(0);
|
||||
|
||||
popup.setPlacement('right');
|
||||
elems = goog.dom.getElementsByClass('ol-popup-top');
|
||||
expect(elems.length).toBe(0);
|
||||
elems = goog.dom.getElementsByClass('ol-popup-right');
|
||||
expect(elems.length).toBe(1);
|
||||
|
||||
popup.close();
|
||||
});
|
||||
|
||||
it("should be able to use a user provided container", function() {
|
||||
|
||||
var point = ol.geom.point([21, 4]);
|
||||
var feat = ol.feature().geometry(point).set('name', 'foo');
|
||||
var map = ol.map();
|
||||
var popup = ol.popup({
|
||||
map: map,
|
||||
template: '<p>hello popup template! #ol3 feature name: {{name}}</p>'
|
||||
});
|
||||
|
||||
expect(popup).toBeA(ol.Popup);
|
||||
popup.open(feat);
|
||||
//expect?
|
||||
|
||||
pop.template();
|
||||
|
||||
popup.close();
|
||||
expect(goog.dom.getElementsByClass('ol-popup')).toBeNull();
|
||||
});
|
||||
*/
|
||||
|
||||
});
|
||||
|
||||
@@ -1,20 +0,0 @@
|
||||
describe("ol.Projection", function() {
|
||||
|
||||
it("handles transforms", function() {
|
||||
|
||||
var point = {x: 10, y: 20, z: 30};
|
||||
|
||||
var to = new ol.Projection("EPSG:4326");
|
||||
var from = new ol.Projection("EPSG:900913");
|
||||
var ret = ol.Projection.transform(point, to, from);
|
||||
|
||||
expect(ret).toBeUndefined();
|
||||
|
||||
// original is modified
|
||||
expect(point.x.toFixed(3)).toBe("1113194.908");
|
||||
expect(point.y.toFixed(3)).toBe("2273030.927");
|
||||
expect(point.z).toBe(30);
|
||||
|
||||
});
|
||||
|
||||
});
|
||||
@@ -1,70 +0,0 @@
|
||||
describe("ol.Tile", function() {
|
||||
|
||||
describe("create a tile constructor", function() {
|
||||
it("returns a constructor than can create tiles with expected properties", function() {
|
||||
var Tile = ol.Tile.createConstructor(100, 100);
|
||||
expect(typeof Tile).toEqual("function");
|
||||
var tile = new Tile('url');
|
||||
expect(tile).toBeA(ol.Tile);
|
||||
expect(tile.getImg().className).toEqual('olTile');
|
||||
expect(tile.getImg().style.width).toEqual("100px");
|
||||
expect(tile.getImg().style.height).toEqual("100px");
|
||||
});
|
||||
});
|
||||
|
||||
describe("create a tile", function() {
|
||||
var tile;
|
||||
beforeEach(function() {
|
||||
var Tile = ol.Tile.createConstructor(200, 200);
|
||||
tile = new Tile('http://a.url');
|
||||
});
|
||||
it("creates a tile instance", function() {
|
||||
expect(tile).toBeA(ol.Tile);
|
||||
});
|
||||
it("sets an image node in the instance", function() {
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe("handle image load", function() {
|
||||
var tile;
|
||||
beforeEach(function() {
|
||||
var Tile = ol.Tile.createConstructor(200, 200);
|
||||
tile = new Tile('http://a.url');
|
||||
});
|
||||
it("fires a load event", function() {
|
||||
var spy = jasmine.createSpy();
|
||||
goog.events.listen(tile, 'load', spy);
|
||||
tile.handleImageLoad();
|
||||
expect(spy).toHaveBeenCalled();
|
||||
});
|
||||
it("sets the loaded flag", function() {
|
||||
tile.handleImageLoad();
|
||||
expect(tile.isLoaded()).toBeTruthy();
|
||||
});
|
||||
it("unsets the loading flag", function() {
|
||||
tile.loading_ = true;
|
||||
tile.handleImageLoad();
|
||||
expect(tile.isLoading()).toBeFalsy();
|
||||
});
|
||||
});
|
||||
|
||||
describe("handle image error", function() {
|
||||
var tile;
|
||||
beforeEach(function() {
|
||||
var Tile = ol.Tile.createConstructor(200, 200);
|
||||
tile = new Tile('http://a.url');
|
||||
});
|
||||
it("fires a load event", function() {
|
||||
var spy = jasmine.createSpy();
|
||||
goog.events.listen(tile, 'error', spy);
|
||||
tile.handleImageError();
|
||||
expect(spy).toHaveBeenCalled();
|
||||
});
|
||||
it("unsets the loading flag", function() {
|
||||
tile.loading_ = true;
|
||||
tile.handleImageError();
|
||||
expect(tile.isLoading()).toBeFalsy();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,39 +0,0 @@
|
||||
describe('ol.TileCache', function() {
|
||||
|
||||
describe('add tiles to cache', function() {
|
||||
var Tile, tilecache;
|
||||
|
||||
beforeEach(function() {
|
||||
Tile = ol.Tile.createConstructor(200, 200);
|
||||
tilecache = new ol.TileCache(5);
|
||||
});
|
||||
|
||||
it('does add tiles, without exceeding cache size', function() {
|
||||
for (var i=0; i<6; i++) {
|
||||
var url = 'url' + i;
|
||||
var tile = new Tile(url);
|
||||
tilecache.set(url, tile);
|
||||
}
|
||||
expect(tilecache.getCount()).toEqual(5);
|
||||
});
|
||||
});
|
||||
|
||||
describe('exceed the cache capacity', function() {
|
||||
|
||||
var Tile, tilecache, tile;
|
||||
|
||||
beforeEach(function() {
|
||||
Tile = ol.Tile.createConstructor(200, 200);
|
||||
tilecache = new ol.TileCache(1);
|
||||
tile = new Tile('url1');
|
||||
tilecache.set('url1', tile);
|
||||
spyOn(tile, 'destroy');
|
||||
});
|
||||
|
||||
it('calls tile.destroy', function() {
|
||||
tilecache.set('url2', new Tile('url2'));
|
||||
expect(tile.destroy).toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
@@ -1,21 +0,0 @@
|
||||
describe("ol.TileSet", function() {
|
||||
describe("creating a tileset", function() {
|
||||
it("creates a tileset instance", function() {
|
||||
var tileset = new ol.TileSet();
|
||||
expect(tileset).toBeA(ol.TileSet);
|
||||
});
|
||||
});
|
||||
describe("getter methods", function() {
|
||||
var tileSet = new ol.TileSet([], 123, 456, 10);
|
||||
|
||||
it("allows getting tile width", function() {
|
||||
expect(tileSet.getTileWidth()).toBe(123);
|
||||
});
|
||||
it("allows getting tile height", function() {
|
||||
expect(tileSet.getTileHeight()).toBe(456);
|
||||
});
|
||||
it("allows getting resolution", function() {
|
||||
expect(tileSet.getResolution()).toBe(10);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,57 +0,0 @@
|
||||
describe("ol.UnreferencedBounds", function() {
|
||||
|
||||
describe("creating a bounds", function() {
|
||||
it("creates a bounds instance", function() {
|
||||
var bounds = new ol.UnreferencedBounds(1, 2, 3, 4);
|
||||
expect(bounds).toBeA(ol.UnreferencedBounds);
|
||||
});
|
||||
});
|
||||
describe("getting properties", function() {
|
||||
var bounds = new ol.UnreferencedBounds(10, 20, 30, 50);
|
||||
|
||||
it("allows getting width", function() {
|
||||
expect(bounds.getWidth()).toBe(20);
|
||||
});
|
||||
|
||||
it("allows getting height", function() {
|
||||
expect(bounds.getHeight()).toBe(30);
|
||||
});
|
||||
});
|
||||
|
||||
describe("intersection", function() {
|
||||
|
||||
var aBounds = new ol.UnreferencedBounds(-180, -90, 180, 90);
|
||||
|
||||
it("works when within", function() {
|
||||
var bBounds = new ol.UnreferencedBounds(-20, -10, 20, 10);
|
||||
expect(aBounds.intersects(bBounds)).toBe(true);
|
||||
expect(bBounds.intersects(aBounds)).toBe(true);
|
||||
});
|
||||
|
||||
it("works when contains", function() {
|
||||
var bBounds = new ol.UnreferencedBounds(-181, -91, 181, 91);
|
||||
expect(aBounds.intersects(bBounds)).toBe(true);
|
||||
expect(bBounds.intersects(aBounds)).toBe(true);
|
||||
});
|
||||
|
||||
it("works when total intersect", function() {
|
||||
var bBounds = new ol.UnreferencedBounds(-185, -100, 20, 50);
|
||||
expect(aBounds.intersects(bBounds)).toBe(true);
|
||||
expect(bBounds.intersects(aBounds)).toBe(true);
|
||||
});
|
||||
|
||||
it("works when borders intersect", function() {
|
||||
var bBounds = new ol.UnreferencedBounds(-360, -180, -180, -90);
|
||||
expect(aBounds.intersects(bBounds)).toBe(true);
|
||||
expect(bBounds.intersects(aBounds)).toBe(true);
|
||||
});
|
||||
|
||||
it("works when no intersect", function() {
|
||||
var bBounds = new ol.UnreferencedBounds(-360, -180, -185, -95);
|
||||
expect(aBounds.intersects(bBounds)).toBe(false);
|
||||
expect(bBounds.intersects(aBounds)).toBe(false);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
});
|
||||
@@ -1,34 +0,0 @@
|
||||
describe('ol.control.Control', function() {
|
||||
|
||||
it('should be easy to create and destroy a control', function() {
|
||||
var control = new ol.control.Control();
|
||||
expect(control).toBeA(ol.control.Control);
|
||||
expect(control.autoActivate_).toBe(false);
|
||||
|
||||
control.destroy();
|
||||
expect(control.autoActivate_).toBeUndefined();
|
||||
});
|
||||
|
||||
it('can be activated and deactivated', function() {
|
||||
var control = new ol.control.Control();
|
||||
expect(control.active_).toBe(false);
|
||||
expect(control.activate()).toBe(true);
|
||||
expect(control.active_).toBe(true);
|
||||
expect(control.activate()).toBe(false);
|
||||
expect(control.deactivate()).toBe(true);
|
||||
expect(control.active_).toBe(false);
|
||||
expect(control.deactivate()).toBe(false);
|
||||
control.destroy();
|
||||
});
|
||||
|
||||
it('auto-activates itself and can be added to a map', function() {
|
||||
control = new ol.control.Control();
|
||||
control.setMap('foo');
|
||||
expect(control.map_).toBe('foo');
|
||||
expect(control.active_).toBe(false);
|
||||
control.autoActivate_ = true;
|
||||
control.setMap('bar');
|
||||
expect(control.map_).toBe('bar');
|
||||
expect(control.active_).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,179 +0,0 @@
|
||||
describe("ol.geom.Collection", function() {
|
||||
var c;
|
||||
|
||||
beforeEach(function(){
|
||||
c = new ol.geom.Collection([
|
||||
new ol.geom.Point(10,20),
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(47,11),
|
||||
new ol.geom.Point(3.14,2.8)
|
||||
])
|
||||
]);
|
||||
});
|
||||
|
||||
afterEach(function(){
|
||||
c = null;
|
||||
});
|
||||
|
||||
it("constructs instances", function() {
|
||||
expect( c ).toBeA( ol.geom.Collection );
|
||||
});
|
||||
|
||||
it("can construct instances without any components", function() {
|
||||
// empty array
|
||||
c = new ol.geom.Collection([]);
|
||||
expect( c ).toBeA( ol.geom.Collection );
|
||||
|
||||
// no argument at all
|
||||
c = new ol.geom.Collection();
|
||||
expect( c ).toBeA( ol.geom.Collection );
|
||||
});
|
||||
|
||||
it("cannot construct instances when passed illegal components", function() {
|
||||
// collection cannot contain collections
|
||||
expect(function(){
|
||||
c = new ol.geom.Collection([
|
||||
new ol.geom.Collection()
|
||||
]);
|
||||
}).toThrow();
|
||||
|
||||
});
|
||||
|
||||
it("inherits from ol.geom.Geometry", function() {
|
||||
expect( c ).toBeA( ol.geom.Geometry );
|
||||
});
|
||||
|
||||
it("has a working getter for components", function() {
|
||||
|
||||
var components = c.getComponents();
|
||||
|
||||
expect( components ).toBeA( Array );
|
||||
expect( components.length ).toBe( 2 );
|
||||
expect( components[0] ).toBeA( ol.geom.Point );
|
||||
expect( components[1] ).toBeA( ol.geom.LineString );
|
||||
|
||||
expect( components[0].getX() + ',' + components[0].getY()).toBe( '10,20' );
|
||||
expect( components[1].getVertices()[0].getX() + ',' + components[1].getVertices()[0].getY()).toBe( '47,11' );
|
||||
|
||||
});
|
||||
|
||||
it("has a working setter for components", function() {
|
||||
|
||||
c.setComponents([
|
||||
new ol.geom.Point(30,40),
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(3,9),
|
||||
new ol.geom.Point(4,16)
|
||||
])
|
||||
]);
|
||||
|
||||
var components = c.getComponents();
|
||||
|
||||
expect( components.length ).toBe( 2 );
|
||||
expect( components[0] ).toBeA( ol.geom.Point );
|
||||
expect( components[1] ).toBeA( ol.geom.LineString );
|
||||
|
||||
expect( components[0].getX() + ',' + components[0].getY()).toBe( '30,40' );
|
||||
expect( components[1].getVertices()[0].getX() + ',' + components[1].getVertices()[0].getY()).toBe( '3,9' );
|
||||
|
||||
});
|
||||
|
||||
it("has a method to add components", function() {
|
||||
|
||||
c.addComponent(
|
||||
new ol.geom.Point(30,40),
|
||||
1
|
||||
);
|
||||
c.addComponent(
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(5,25),
|
||||
new ol.geom.Point(6,36)
|
||||
]),
|
||||
0
|
||||
);
|
||||
|
||||
var components = c.getComponents();
|
||||
|
||||
expect( components.length ).toBe( 4 );
|
||||
expect( components[0].getVertices()[0].getX() + ',' + components[0].getVertices()[0].getY()).toBe( '5,25' );
|
||||
expect( components[1].getX() + ',' + components[1].getY()).toBe( '10,20' );
|
||||
expect( components[2].getX() + ',' + components[2].getY()).toBe( '30,40' );
|
||||
expect( components[3].getVertices()[0].getX() + ',' + components[3].getVertices()[0].getY()).toBe( '47,11' );
|
||||
|
||||
});
|
||||
|
||||
it("cannot add instances of 'ol.geom.Collection'", function(){
|
||||
expect(function(){
|
||||
c.addComponent(
|
||||
new ol.geom.Collection([
|
||||
new ol.geom.Point(5,25),
|
||||
new ol.geom.Point(6,36)
|
||||
])
|
||||
);
|
||||
}).toThrow();
|
||||
});
|
||||
|
||||
it("allows instances of 'ol.geom.Multi*' (even though these are subclasses of ol.geom.Collection)", function(){
|
||||
expect(function(){
|
||||
c.addComponent(
|
||||
new ol.geom.MultiPoint([
|
||||
new ol.geom.Point(5,25),
|
||||
new ol.geom.Point(6,36)
|
||||
])
|
||||
);
|
||||
}).not.toThrow();
|
||||
});
|
||||
|
||||
it("has a method to remove components", function() {
|
||||
c.setComponents([
|
||||
new ol.geom.Point(0,10),
|
||||
new ol.geom.Point(10,20),
|
||||
new ol.geom.Point(20,30),
|
||||
new ol.geom.Point(30,40)
|
||||
]);
|
||||
|
||||
var p = c.getComponents()[2]; // 20,30;
|
||||
|
||||
c.removeComponent( p );
|
||||
|
||||
var components = c.getComponents();
|
||||
|
||||
expect( components.length ).toBe( 3 );
|
||||
expect( components[0].getX() + ',' + components[0].getY()).toBe( '0,10' );
|
||||
expect( components[1].getX() + ',' + components[1].getY()).toBe( '10,20' );
|
||||
expect( components[2].getX() + ',' + components[2].getY()).toBe( '30,40' );
|
||||
});
|
||||
|
||||
describe("the getCentroid method is functional", function(){
|
||||
it("returns an instance of ol.geom.Point", function(){
|
||||
expect(c.getCentroid()).toBeA(ol.geom.Point);
|
||||
});
|
||||
|
||||
it("does not choke when components returns a null centroid", function(){
|
||||
var centroid;
|
||||
expect(
|
||||
function(){
|
||||
c.addComponent(new ol.geom.LineString([]));
|
||||
centroid = c.getCentroid();
|
||||
}
|
||||
).not.toThrow();
|
||||
|
||||
expect(centroid).toBeA(ol.geom.Point);
|
||||
});
|
||||
|
||||
it("has the expected coordinates", function(){
|
||||
c = new ol.geom.Collection([
|
||||
new ol.geom.Point(10,10),
|
||||
new ol.geom.Point(30,30),
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(10,10),
|
||||
new ol.geom.Point(10,30),
|
||||
new ol.geom.Point(30,30),
|
||||
new ol.geom.Point(30,10)
|
||||
])
|
||||
]);
|
||||
var centroid = c.getCentroid();
|
||||
expect(centroid.getX() + ',' + centroid.getY()).toBe('20,20');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,131 +0,0 @@
|
||||
describe("ol.geom.LineString", function() {
|
||||
var ls;
|
||||
|
||||
beforeEach(function(){
|
||||
ls = new ol.geom.LineString([
|
||||
new ol.geom.Point(0,0),
|
||||
new ol.geom.Point(10,10),
|
||||
new ol.geom.Point(10,0),
|
||||
new ol.geom.Point(20,20)
|
||||
]);
|
||||
});
|
||||
|
||||
afterEach(function(){
|
||||
ls = null;
|
||||
});
|
||||
|
||||
it("constructs instances", function() {
|
||||
expect( ls ).toBeA( ol.geom.LineString );
|
||||
});
|
||||
|
||||
it("can construct instances without any points", function() {
|
||||
// empty array
|
||||
mp = new ol.geom.LineString([]);
|
||||
expect( ls ).toBeA( ol.geom.LineString );
|
||||
|
||||
// no argument at all
|
||||
mp = new ol.geom.LineString();
|
||||
expect( ls ).toBeA( ol.geom.LineString );
|
||||
});
|
||||
|
||||
it("inherits from ol.geom.Geometry", function() {
|
||||
expect( ls ).toBeA( ol.geom.Geometry );
|
||||
});
|
||||
|
||||
it("has a working getter for vertices", function() {
|
||||
|
||||
var vertices = ls.getVertices();
|
||||
|
||||
expect( vertices ).toBeA( Array );
|
||||
expect( vertices.length ).toBe( 4 );
|
||||
expect( vertices[0] ).toBeA( ol.geom.Point );
|
||||
|
||||
expect( vertices[0].getX() + ',' + vertices[0].getY()).toBe( '0,0' );
|
||||
|
||||
});
|
||||
|
||||
it("has a working setter for vertices", function() {
|
||||
|
||||
ls.setVertices([
|
||||
new ol.geom.Point(30,40),
|
||||
new ol.geom.Point(50,60)
|
||||
]);
|
||||
|
||||
var vertices = ls.getVertices();
|
||||
|
||||
expect( vertices.length ).toBe( 2 );
|
||||
expect( vertices[0] ).toBeA( ol.geom.Point );
|
||||
expect( vertices[1] ).toBeA( ol.geom.Point );
|
||||
|
||||
expect( vertices[0].getX() + ',' + vertices[0].getY()).toBe( '30,40' );
|
||||
expect( vertices[1].getX() + ',' + vertices[1].getY()).toBe( '50,60' );
|
||||
|
||||
});
|
||||
|
||||
it("has a method to add vertices", function() {
|
||||
|
||||
ls.addVertex(
|
||||
new ol.geom.Point(30,40),
|
||||
1
|
||||
);
|
||||
ls.addVertex(
|
||||
new ol.geom.Point(50,60),
|
||||
2
|
||||
);
|
||||
ls.addVertex(
|
||||
new ol.geom.Point(-10,0),
|
||||
0
|
||||
);
|
||||
|
||||
var vertices = ls.getVertices();
|
||||
|
||||
expect( vertices.length ).toBe( 7 );
|
||||
expect( vertices[0].getX() + ',' + vertices[0].getY()).toBe( '-10,0' );
|
||||
expect( vertices[1].getX() + ',' + vertices[1].getY()).toBe( '0,0' );
|
||||
expect( vertices[2].getX() + ',' + vertices[2].getY()).toBe( '30,40' );
|
||||
expect( vertices[3].getX() + ',' + vertices[3].getY()).toBe( '50,60' );
|
||||
expect( vertices[4].getX() + ',' + vertices[4].getY()).toBe( '10,10' );
|
||||
expect( vertices[5].getX() + ',' + vertices[5].getY()).toBe( '10,0' );
|
||||
expect( vertices[6].getX() + ',' + vertices[6].getY()).toBe( '20,20' );
|
||||
|
||||
});
|
||||
|
||||
it("has a method to remove vertices", function() {
|
||||
ls.setVertices([
|
||||
new ol.geom.Point(0,10),
|
||||
new ol.geom.Point(10,20),
|
||||
new ol.geom.Point(20,30),
|
||||
new ol.geom.Point(30,40)
|
||||
]);
|
||||
|
||||
var v = ls.getVertices()[2]; // 20,30;
|
||||
|
||||
ls.removeVertex( v );
|
||||
|
||||
var vertices = ls.getVertices();
|
||||
|
||||
expect( vertices.length ).toBe( 3 );
|
||||
expect( vertices[0].getX() + ',' + vertices[0].getY()).toBe( '0,10' );
|
||||
expect( vertices[1].getX() + ',' + vertices[1].getY()).toBe( '10,20' );
|
||||
expect( vertices[2].getX() + ',' + vertices[2].getY()).toBe( '30,40' );
|
||||
});
|
||||
|
||||
describe("the getCentroid method is functional", function(){
|
||||
it("returns an instance of ol.geom.Point", function(){
|
||||
expect(ls.getCentroid()).toBeA(ol.geom.Point);
|
||||
});
|
||||
|
||||
it("has the expected coordinates", function(){
|
||||
|
||||
ls.setVertices([
|
||||
new ol.geom.Point(0.5, 1),
|
||||
new ol.geom.Point(1, 1.5),
|
||||
new ol.geom.Point(1.5, 1),
|
||||
new ol.geom.Point(1, 0.5)
|
||||
]);
|
||||
var c = ls.getCentroid();
|
||||
|
||||
expect(c.getX() + ',' + c.getY()).toBe('1,1');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,229 +0,0 @@
|
||||
describe("ol.geom.MultiLineString", function() {
|
||||
|
||||
var mls,
|
||||
formatPoint = function(p){
|
||||
return p.getX() + ',' + p.getY();
|
||||
},
|
||||
linestringNPointN = function(mls, i, j) {
|
||||
return formatPoint(mls.getLineStrings()[i].getVertices()[j]);
|
||||
};
|
||||
|
||||
beforeEach(function(){
|
||||
mls = new ol.geom.MultiLineString([
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(10,10),
|
||||
new ol.geom.Point(10,0),
|
||||
new ol.geom.Point(20,20)
|
||||
]),
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(30,10),
|
||||
new ol.geom.Point(30,0),
|
||||
new ol.geom.Point(40,20)
|
||||
])
|
||||
]);
|
||||
});
|
||||
|
||||
afterEach(function(){
|
||||
mls = null;
|
||||
});
|
||||
|
||||
it("constructs instances", function() {
|
||||
expect( mls ).toBeA( ol.geom.MultiLineString );
|
||||
});
|
||||
|
||||
it("can construct instances without any linestrings", function() {
|
||||
// empty array
|
||||
mls = new ol.geom.MultiLineString([]);
|
||||
expect( mls ).toBeA( ol.geom.MultiLineString );
|
||||
|
||||
// no argument at all
|
||||
mls = new ol.geom.MultiLineString();
|
||||
expect( mls ).toBeA( ol.geom.MultiLineString );
|
||||
});
|
||||
|
||||
it("cannot be constructed with component-types other than 'ol.geom.Point'", function() {
|
||||
expect(function(){
|
||||
mls = new ol.geom.MultiLineString([
|
||||
new ol.geom.Point()
|
||||
]);
|
||||
}).toThrow();
|
||||
|
||||
expect(function(){
|
||||
mls = new ol.geom.MultiLineString([
|
||||
new ol.geom.MultiPoint([
|
||||
new ol.geom.Point()
|
||||
])
|
||||
]);
|
||||
}).toThrow();
|
||||
});
|
||||
|
||||
it("inherits from ol.geom.Geometry", function() {
|
||||
expect( mls ).toBeA( ol.geom.Geometry );
|
||||
});
|
||||
|
||||
it("has a working getter for linestrings", function() {
|
||||
|
||||
var linestrings = mls.getLineStrings();
|
||||
|
||||
expect( linestrings ).toBeA( Array );
|
||||
expect( linestrings.length ).toBe( 2 );
|
||||
expect( linestrings[0] ).toBeA( ol.geom.LineString );
|
||||
|
||||
expect( linestringNPointN(mls, 0, 0) ).toBe( '10,10' );
|
||||
|
||||
});
|
||||
|
||||
it("has a working setter for linestrings", function() {
|
||||
|
||||
mls.setLineStrings([
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(-10,10),
|
||||
new ol.geom.Point(-10,0),
|
||||
new ol.geom.Point(-20,20)
|
||||
])
|
||||
]);
|
||||
|
||||
var linestrings = mls.getLineStrings();
|
||||
|
||||
expect( linestrings.length ).toBe( 1 );
|
||||
expect( linestrings[0] ).toBeA( ol.geom.LineString );
|
||||
|
||||
expect( linestringNPointN(mls, 0, 0) ).toBe( '-10,10' );
|
||||
|
||||
});
|
||||
|
||||
it("has a method to add linestrings", function() {
|
||||
|
||||
mls.addLineString(
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(11,11),
|
||||
new ol.geom.Point(11,1),
|
||||
new ol.geom.Point(21,21)
|
||||
]),
|
||||
1
|
||||
);
|
||||
mls.addLineString(
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(9,9),
|
||||
new ol.geom.Point(9,-1),
|
||||
new ol.geom.Point(19,19)
|
||||
]),
|
||||
0
|
||||
);
|
||||
mls.addLineString(
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(31,11),
|
||||
new ol.geom.Point(31,1),
|
||||
new ol.geom.Point(41,21)
|
||||
]),
|
||||
4
|
||||
);
|
||||
|
||||
var linestrings = mls.getLineStrings();
|
||||
|
||||
expect( linestrings.length ).toBe( 5 );
|
||||
expect( linestringNPointN(mls, 0, 0) ).toBe( '9,9' );
|
||||
expect( linestringNPointN(mls, 1, 0) ).toBe( '10,10' );
|
||||
expect( linestringNPointN(mls, 2, 0) ).toBe( '11,11' );
|
||||
expect( linestringNPointN(mls, 3, 0) ).toBe( '30,10' );
|
||||
expect( linestringNPointN(mls, 4, 0) ).toBe( '31,11' );
|
||||
});
|
||||
|
||||
it("has a method to remove linestrings", function() {
|
||||
mls.setLineStrings([
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(9,9),
|
||||
new ol.geom.Point(9,-1),
|
||||
new ol.geom.Point(19,19)
|
||||
]),
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(10,10),
|
||||
new ol.geom.Point(10,0),
|
||||
new ol.geom.Point(20,20)
|
||||
]),
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(11,11),
|
||||
new ol.geom.Point(11,1),
|
||||
new ol.geom.Point(21,21)
|
||||
])
|
||||
]);
|
||||
|
||||
var ls = mls.getLineStrings()[1]; // p1: 10,10;
|
||||
|
||||
mls.removeLineString( ls );
|
||||
|
||||
var linestrings = mls.getLineStrings();
|
||||
|
||||
expect( linestrings.length ).toBe( 2 );
|
||||
|
||||
expect( linestringNPointN(mls, 0, 0) ).toBe( '9,9' );
|
||||
expect( linestringNPointN(mls, 1, 0) ).toBe( '11,11' );
|
||||
|
||||
});
|
||||
|
||||
describe('The setters ensure only linestrings can be added', function(){
|
||||
|
||||
it('addLineString cannot be tricked', function(){
|
||||
expect(function(){
|
||||
mls.addLineString(
|
||||
new ol.geom.Point(30,40)
|
||||
);
|
||||
}).toThrow();
|
||||
|
||||
expect(function(){
|
||||
mls.addLineString(
|
||||
new ol.geom.MultiPoint()
|
||||
);
|
||||
}).toThrow();
|
||||
|
||||
expect(function(){
|
||||
mls.addLineString(
|
||||
new ol.geom.Collection()
|
||||
);
|
||||
}).toThrow();
|
||||
|
||||
});
|
||||
|
||||
it('addComponent cannot be tricked', function(){
|
||||
expect(function(){
|
||||
mls.addComponent(
|
||||
new ol.geom.Point(30,40)
|
||||
);
|
||||
}).toThrow();
|
||||
|
||||
expect(function(){
|
||||
mls.addComponent(
|
||||
new ol.geom.MultiPoint()
|
||||
);
|
||||
}).toThrow();
|
||||
|
||||
expect(function(){
|
||||
mls.addComponent(
|
||||
new ol.geom.Collection()
|
||||
);
|
||||
}).toThrow();
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe("the getCentroid method is functional", function(){
|
||||
it("returns an instance of ol.geom.Point", function(){
|
||||
expect(mls.getCentroid()).toBeA(ol.geom.Point);
|
||||
});
|
||||
|
||||
it("has the expected coordinates", function(){
|
||||
mls.setLineStrings([
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(0,40),
|
||||
new ol.geom.Point(40,40)
|
||||
]),
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(0,0),
|
||||
new ol.geom.Point(40,40)
|
||||
])
|
||||
]);
|
||||
var c = mls.getCentroid();
|
||||
expect( formatPoint(c) ).toBe('20,20');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,141 +0,0 @@
|
||||
describe("ol.geom.MultiPoint", function() {
|
||||
var mp;
|
||||
|
||||
beforeEach(function(){
|
||||
mp = new ol.geom.MultiPoint([
|
||||
new ol.geom.Point(10,20)
|
||||
]);
|
||||
});
|
||||
|
||||
afterEach(function(){
|
||||
mp = null;
|
||||
});
|
||||
|
||||
it("constructs instances", function() {
|
||||
expect( mp ).toBeA( ol.geom.MultiPoint );
|
||||
});
|
||||
|
||||
it("can construct instances without any points", function() {
|
||||
// empty array
|
||||
mp = new ol.geom.MultiPoint([]);
|
||||
expect( mp ).toBeA( ol.geom.MultiPoint );
|
||||
|
||||
// no argument at all
|
||||
mp = new ol.geom.MultiPoint();
|
||||
expect( mp ).toBeA( ol.geom.MultiPoint );
|
||||
});
|
||||
|
||||
it("cannot be constructed with component-types other than 'ol.geom.Point'", function() {
|
||||
expect(function(){
|
||||
mp = new ol.geom.MultiPoint([
|
||||
new ol.geom.LineString()
|
||||
]);
|
||||
}).toThrow();
|
||||
});
|
||||
|
||||
it("inherits from ol.geom.Geometry", function() {
|
||||
expect( mp ).toBeA( ol.geom.Geometry );
|
||||
});
|
||||
|
||||
it("has a working getter for points", function() {
|
||||
|
||||
var points = mp.getPoints();
|
||||
|
||||
expect( points ).toBeA( Array );
|
||||
expect( points.length ).toBe( 1 );
|
||||
expect( points[0] ).toBeA( ol.geom.Point );
|
||||
|
||||
expect( points[0].getX() + ',' + points[0].getY()).toBe( '10,20' );
|
||||
|
||||
});
|
||||
|
||||
it("has a working setter for points", function() {
|
||||
|
||||
mp.setPoints([
|
||||
new ol.geom.Point(30,40),
|
||||
new ol.geom.Point(50,60)
|
||||
]);
|
||||
|
||||
var points = mp.getPoints();
|
||||
|
||||
expect( points.length ).toBe( 2 );
|
||||
expect( points[0] ).toBeA( ol.geom.Point );
|
||||
expect( points[1] ).toBeA( ol.geom.Point );
|
||||
|
||||
expect( points[0].getX() + ',' + points[0].getY()).toBe( '30,40' );
|
||||
expect( points[1].getX() + ',' + points[1].getY()).toBe( '50,60' );
|
||||
|
||||
});
|
||||
|
||||
it("has a method to add points", function() {
|
||||
|
||||
mp.addPoint(
|
||||
new ol.geom.Point(30,40),
|
||||
1
|
||||
);
|
||||
mp.addPoint(
|
||||
new ol.geom.Point(50,60),
|
||||
2
|
||||
);
|
||||
mp.addPoint(
|
||||
new ol.geom.Point(-10,0),
|
||||
0
|
||||
);
|
||||
|
||||
var points = mp.getPoints();
|
||||
|
||||
expect( points.length ).toBe( 4 );
|
||||
expect( points[0].getX() + ',' + points[0].getY()).toBe( '-10,0' );
|
||||
expect( points[1].getX() + ',' + points[1].getY()).toBe( '10,20' );
|
||||
expect( points[2].getX() + ',' + points[2].getY()).toBe( '30,40' );
|
||||
expect( points[3].getX() + ',' + points[3].getY()).toBe( '50,60' );
|
||||
|
||||
});
|
||||
|
||||
it("can only add ol.geom.Point as components", function() {
|
||||
expect(function(){
|
||||
mp.addComponent(
|
||||
new ol.geom.LineString([
|
||||
new ol.geom.Point(30,40),
|
||||
new ol.geom.Point(50,60)
|
||||
])
|
||||
);
|
||||
}).toThrow();
|
||||
});
|
||||
|
||||
it("has a method to remove points", function() {
|
||||
mp.setPoints([
|
||||
new ol.geom.Point(0,10),
|
||||
new ol.geom.Point(10,20),
|
||||
new ol.geom.Point(20,30),
|
||||
new ol.geom.Point(30,40)
|
||||
]);
|
||||
|
||||
var p = mp.getPoints()[2]; // 20,30;
|
||||
|
||||
mp.removePoint( p );
|
||||
|
||||
var points = mp.getPoints();
|
||||
|
||||
expect( points.length ).toBe( 3 );
|
||||
expect( points[0].getX() + ',' + points[0].getY()).toBe( '0,10' );
|
||||
expect( points[1].getX() + ',' + points[1].getY()).toBe( '10,20' );
|
||||
expect( points[2].getX() + ',' + points[2].getY()).toBe( '30,40' );
|
||||
});
|
||||
|
||||
describe("the getCentroid method is functional", function(){
|
||||
it("returns an instance of ol.geom.Point", function(){
|
||||
expect(mp.getCentroid()).toBeA(ol.geom.Point);
|
||||
});
|
||||
|
||||
it("has the expected coordinates", function(){
|
||||
mp.setPoints([
|
||||
new ol.geom.Point(10,10),
|
||||
new ol.geom.Point(20,20),
|
||||
new ol.geom.Point(30,30)
|
||||
]);
|
||||
var c = mp.getCentroid();
|
||||
expect(c.getX() + ',' + c.getY()).toBe('20,20');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,149 +0,0 @@
|
||||
describe("ol.geom.Point", function() {
|
||||
var p2Args,
|
||||
p3Args,
|
||||
p4Args,
|
||||
proj = "EPSG:4326";
|
||||
|
||||
var instances = {
|
||||
"two arguments <x>,<y> passed": new ol.geom.Point(21, 4),
|
||||
"three arguments <x>,<y>,<z> passed": new ol.geom.Point(21, 4, 8),
|
||||
"four arguments <x>,<y>,<z>,<projection> passed": new ol.geom.Point(21, 4, 8, proj)
|
||||
};
|
||||
|
||||
beforeEach(function() {
|
||||
proj = ol.projection("EPSG:4326");
|
||||
instances = {
|
||||
"two arguments <x>,<y> passed": new ol.geom.Point(21, 4),
|
||||
"three arguments <x>,<y>,<z> passed": new ol.geom.Point(21, 4, 8),
|
||||
"four arguments <x>,<y>,<z>,<projection> passed": new ol.geom.Point(21, 4, 8, proj)
|
||||
};
|
||||
p2Args = instances['two arguments <x>,<y> passed'];
|
||||
p3Args = instances['three arguments <x>,<y>,<z> passed'];
|
||||
p4Args = instances['four arguments <x>,<y>,<z>,<projection> passed'];
|
||||
});
|
||||
|
||||
afterEach(function() {
|
||||
p2Args = p3Args = p4Args = null;
|
||||
instances = {
|
||||
"two arguments <x>,<y> passed": new ol.geom.Point(21, 4),
|
||||
"three arguments <x>,<y>,<z> passed": new ol.geom.Point(21, 4, 8),
|
||||
"four arguments <x>,<y>,<z>,<projection> passed": new ol.geom.Point(21, 4, 8, proj)
|
||||
};
|
||||
});
|
||||
|
||||
for (instancesDesc in instances) {
|
||||
if (instances.hasOwnProperty(instancesDesc)) {
|
||||
var instance = instances[instancesDesc];
|
||||
|
||||
describe("instantiate with " + instancesDesc, function() {
|
||||
|
||||
it("constructs instances", function() {
|
||||
expect(instance).toEqual(jasmine.any(ol.geom.Point));
|
||||
});
|
||||
|
||||
it("constructs instances of ol.geom.Geometry", function() {
|
||||
expect(instance).toEqual(jasmine.any(ol.geom.Geometry));
|
||||
});
|
||||
|
||||
it("has the coordinate accessor methods", function() {
|
||||
expect(instance.getX).not.toBeUndefined();
|
||||
expect(instance.getY).not.toBeUndefined();
|
||||
expect(instance.getZ).not.toBeUndefined();
|
||||
expect(instance.setX).not.toBeUndefined();
|
||||
expect(instance.setY).not.toBeUndefined();
|
||||
expect(instance.setZ).not.toBeUndefined();
|
||||
});
|
||||
|
||||
it("has the projection accessor methods", function() {
|
||||
expect(instance.getProjection).not.toBeUndefined();
|
||||
expect(instance.setProjection).not.toBeUndefined();
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
describe('the getters are functional', function(){
|
||||
it("works when two arguments <x>,<y> passed", function(){
|
||||
|
||||
expect(p2Args.getX()).toBe(21);
|
||||
expect(p2Args.getY()).toBe(4);
|
||||
expect(p2Args.getZ()).toBeUndefined();
|
||||
expect(p2Args.getProjection()).toBeNull();
|
||||
});
|
||||
|
||||
it("works when three arguments <x>,<y>,<z> passed", function(){
|
||||
expect(p3Args.getX()).toBe(21);
|
||||
expect(p3Args.getY()).toBe(4);
|
||||
expect(p3Args.getZ()).not.toBeUndefined();
|
||||
expect(p3Args.getZ()).toBe(8);
|
||||
expect(p3Args.getProjection()).toBeNull();
|
||||
});
|
||||
|
||||
it("works when four arguments <x>,<y>,<z>,<projection> passed", function(){
|
||||
expect(p4Args.getX()).toBe(21);
|
||||
expect(p4Args.getY()).toBe(4);
|
||||
expect(p4Args.getZ()).toBe(8);
|
||||
expect(p4Args.getProjection()).not.toBeNull();
|
||||
expect(p4Args.getProjection()).toBeA(ol.Projection);
|
||||
});
|
||||
});
|
||||
|
||||
describe("transformation is functional", function(){
|
||||
it("can be transformed", function(){
|
||||
// save for later comparison
|
||||
var old = {
|
||||
x: p4Args.getX().toFixed(3),
|
||||
y: p4Args.getY().toFixed(3)
|
||||
};
|
||||
// with code only
|
||||
var transformedPoint = p4Args.transform("EPSG:3857");
|
||||
|
||||
// is it still an instance of ol.geom.Point?
|
||||
expect(transformedPoint).toBeA(ol.geom.Point);
|
||||
// coordinates OK?
|
||||
expect(transformedPoint.getX().toFixed(3)).toBe("2337709.306");
|
||||
expect(transformedPoint.getY().toFixed(3)).toBe("445640.110");
|
||||
|
||||
// with an ol.Projection
|
||||
var retransformedPoint = transformedPoint.transform(new ol.Projection("EPSG:4326"));
|
||||
expect(retransformedPoint).toBeA(ol.geom.Point);
|
||||
|
||||
// coordinates shopulkd be the originally configured
|
||||
expect(retransformedPoint.getX().toFixed(3)).toBe(old.x);
|
||||
expect(retransformedPoint.getY().toFixed(3)).toBe(old.y);
|
||||
});
|
||||
|
||||
it("throws an exception when you try to transform without a source projection", function(){
|
||||
expect(function() {
|
||||
p2Args.transform("EPSG:3857");
|
||||
}).toThrow();
|
||||
|
||||
expect(function() {
|
||||
p3Args.transform("EPSG:3857");
|
||||
}).toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe("the getCentroid method is functional", function(){
|
||||
it("returns an instance of ol.geom.Point", function(){
|
||||
expect(p2Args.getCentroid()).toBeA(ol.geom.Point);
|
||||
expect(p3Args.getCentroid()).toBeA(ol.geom.Point);
|
||||
expect(p4Args.getCentroid()).toBeA(ol.geom.Point);
|
||||
});
|
||||
|
||||
it("does return a clone and not the point itself", function(){
|
||||
expect(p2Args.getCentroid()).not.toBe(p2Args);
|
||||
expect(p3Args.getCentroid()).not.toBe(p3Args);
|
||||
expect(p4Args.getCentroid()).not.toBe(p4Args);
|
||||
});
|
||||
|
||||
it("has the expected coordinates", function(){
|
||||
var c2 = p2Args.getCentroid(),
|
||||
c3 = p3Args.getCentroid(),
|
||||
c4 = p4Args.getCentroid();
|
||||
|
||||
expect(c2.getX() + ',' + c2.getY()).toBe('21,4');
|
||||
expect(c3.getX() + ',' + c3.getY()).toBe('21,4');
|
||||
expect(c4.getX() + ',' + c4.getY()).toBe('21,4');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,47 +0,0 @@
|
||||
describe('ol.handler.Click', function() {
|
||||
var map, elt, listener;
|
||||
|
||||
beforeEach(function() {
|
||||
map = new ol.Map();
|
||||
elt = new goog.events.EventTarget();
|
||||
map.viewport_ = elt;
|
||||
listener = {fn: function() {}};
|
||||
spyOn(listener, 'fn');
|
||||
});
|
||||
|
||||
describe('creating a drag handler', function() {
|
||||
|
||||
it('returns an ol.handler.Click instance', function() {
|
||||
var handler = new ol.handler.Click(map, {});
|
||||
expect(handler).toBeA(ol.handler.Click);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('dispatching events', function() {
|
||||
|
||||
it('dispatches a click event which is an ol.events.MapEvent', function() {
|
||||
new ol.handler.Click(map, {});
|
||||
goog.events.listen(map, 'click', listener.fn);
|
||||
|
||||
goog.events.fireListeners(elt, 'click', false, 'foo');
|
||||
var evt = listener.fn.calls[0].args[0];
|
||||
expect(evt).toBeA(ol.events.MapEvent);
|
||||
expect(evt.originalEvent).toBe('foo');
|
||||
});
|
||||
|
||||
it('ignores click events when the dragged state is set', function() {
|
||||
var states = {};
|
||||
new ol.handler.Click(map, states);
|
||||
goog.events.listen(map, 'click', listener.fn);
|
||||
|
||||
goog.events.fireListeners(elt, 'click', false);
|
||||
expect(listener.fn.calls.length).toBe(1);
|
||||
|
||||
states.dragged = true;
|
||||
goog.events.fireListeners(elt, 'click', false);
|
||||
expect(listener.fn.calls.length).toBe(1);
|
||||
});
|
||||
|
||||
});
|
||||
});
|
||||
@@ -1,77 +0,0 @@
|
||||
describe('ol.handler.Drag', function() {
|
||||
var map;
|
||||
|
||||
beforeEach(function() {
|
||||
map = new ol.Map();
|
||||
var elt = new goog.events.EventTarget();
|
||||
map.viewport_ = elt;
|
||||
});
|
||||
|
||||
describe('creating a drag handler', function() {
|
||||
|
||||
it('returns an ol.handler.Drag instance', function() {
|
||||
var handler = new ol.handler.Drag(map, {});
|
||||
expect(handler).toBeA(ol.handler.Drag);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('dispatching events', function() {
|
||||
var handler, states;
|
||||
|
||||
beforeEach(function() {
|
||||
states = {};
|
||||
handler = new ol.handler.Drag(map, states);
|
||||
});
|
||||
|
||||
it('dragstart, drag and dragend events', function() {
|
||||
var spy = spyOn(goog.events.Event, 'preventDefault').andCallThrough();
|
||||
goog.events.listen(map, ol.events.MapEventType.DRAGSTART, spy);
|
||||
goog.events.listen(map, ol.events.MapEventType.DRAG, spy);
|
||||
goog.events.listen(map, ol.events.MapEventType.DRAGEND, spy);
|
||||
|
||||
handler.dragger_.dispatchEvent({type: goog.fx.Dragger.EventType.START});
|
||||
handler.dragger_.dispatchEvent({type: goog.fx.Dragger.EventType.DRAG});
|
||||
handler.dragger_.dispatchEvent({type: goog.fx.Dragger.EventType.END});
|
||||
|
||||
expect(spy.callCount).toEqual(3);
|
||||
expect(spy.argsForCall[0][0].type).toEqual(ol.events.MapEventType.DRAGSTART);
|
||||
expect(spy.argsForCall[1][0].type).toEqual(ol.events.MapEventType.DRAG);
|
||||
expect(spy.argsForCall[2][0].type).toEqual(ol.events.MapEventType.DRAGEND);
|
||||
});
|
||||
|
||||
it('sets the dragged state during a drag sequence', function() {
|
||||
handler.dragger_.dispatchEvent({type: goog.fx.Dragger.EventType.DRAG});
|
||||
expect(states.dragged).toBeTruthy();
|
||||
|
||||
handler.dragger_.dispatchEvent({type: goog.fx.Dragger.EventType.START});
|
||||
expect(states.dragged).toBeFalsy();
|
||||
});
|
||||
|
||||
it('sets deltaX and deltaY on the ol.event.MapEvent', function() {
|
||||
var spy = spyOn(goog.events.Event, 'preventDefault').andCallThrough();
|
||||
goog.events.listen(map, ol.events.MapEventType.DRAG, spy);
|
||||
|
||||
handler.dragger_.dispatchEvent({type: goog.fx.Dragger.EventType.START,
|
||||
clientX: 2, clientY: 4});
|
||||
handler.dragger_.dispatchEvent({type: goog.fx.Dragger.EventType.DRAG,
|
||||
clientX: 1, clientY: 2});
|
||||
handler.dragger_.dispatchEvent({type: goog.fx.Dragger.EventType.DRAG,
|
||||
clientX: 2, clientY: 4});
|
||||
|
||||
expect(spy.callCount).toEqual(2);
|
||||
expect(spy.argsForCall[0][0].deltaX).toEqual(-1);
|
||||
expect(spy.argsForCall[0][0].deltaY).toEqual(-2);
|
||||
expect(spy.argsForCall[1][0].deltaX).toEqual(1);
|
||||
expect(spy.argsForCall[1][0].deltaY).toEqual(2);
|
||||
});
|
||||
|
||||
it('calls the default action', function() {
|
||||
var handler = new ol.handler.Drag(map, {});
|
||||
var spy = spyOn(handler, 'defaultDrag');
|
||||
|
||||
handler.dragger_.dispatchEvent({type: goog.fx.Dragger.EventType.DRAG});
|
||||
expect(spy).toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,49 +0,0 @@
|
||||
describe('ol.handler.MouseWheel', function() {
|
||||
var map;
|
||||
|
||||
beforeEach(function() {
|
||||
map = new ol.Map();
|
||||
var elt = new goog.events.EventTarget();
|
||||
map.viewport_ = elt;
|
||||
});
|
||||
|
||||
describe('create a mouse wheel handler', function() {
|
||||
|
||||
it('returns an ol.handler.MouseWheel instance', function() {
|
||||
var handler = new ol.handler.MouseWheel(map, {});
|
||||
expect(handler).toBeA(ol.handler.MouseWheel);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('dispatching events', function() {
|
||||
|
||||
var handler;
|
||||
|
||||
beforeEach(function() {
|
||||
handler = new ol.handler.MouseWheel(map, {});
|
||||
});
|
||||
|
||||
it('dispatches a mousewheel event', function() {
|
||||
var spy = spyOn(goog.events.Event, 'preventDefault').andCallThrough();
|
||||
goog.events.listen(map, ol.events.MapEventType.MOUSEWHEEL, spy);
|
||||
|
||||
var evt = new goog.events.MouseWheelEvent(1, 'foo', 0, 1);
|
||||
handler.handler_.dispatchEvent(evt);
|
||||
|
||||
expect(spy).toHaveBeenCalled();
|
||||
expect(spy.argsForCall[0][0].type).toEqual(ol.events.MapEventType.MOUSEWHEEL);
|
||||
});
|
||||
|
||||
it('calls the default action', function() {
|
||||
var handler = new ol.handler.MouseWheel(map, {});
|
||||
spyOn(handler, 'defaultMouseWheel');
|
||||
|
||||
var evt = new goog.events.MouseWheelEvent(1, 'foo', 0, 1);
|
||||
handler.handler_.dispatchEvent(evt);
|
||||
|
||||
expect(handler.defaultMouseWheel).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
});
|
||||
});
|
||||
@@ -1,883 +0,0 @@
|
||||
describe('ol.layer.TileLayer', function() {
|
||||
|
||||
describe('create a tile layer', function() {
|
||||
|
||||
it('returns an ol.layer.TileLayer instance', function() {
|
||||
var layer = new ol.layer.TileLayer();
|
||||
expect(layer instanceof ol.layer.TileLayer).toBe(true);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('get tile size', function() {
|
||||
var layer;
|
||||
|
||||
beforeEach(function() {
|
||||
layer = new ol.layer.TileLayer();
|
||||
});
|
||||
|
||||
it('returns tile size', function() {
|
||||
var tilesize = layer.getTileSize();
|
||||
expect(tilesize).toEqual([256, 256]);
|
||||
});
|
||||
});
|
||||
|
||||
describe('axis orientation', function() {
|
||||
var layer = new ol.layer.TileLayer();
|
||||
|
||||
it('increases from left to right by default', function() {
|
||||
expect(layer.getXRight()).toBe(true);
|
||||
});
|
||||
it('increases from top to bottom by default', function() {
|
||||
expect(layer.getYDown()).toBe(true);
|
||||
});
|
||||
|
||||
it('allows people to set things backwards', function() {
|
||||
var backwards = new ol.layer.TileLayer();
|
||||
backwards.setXRight(false);
|
||||
expect(backwards.getXRight()).toBe(false);
|
||||
backwards.setYDown(false);
|
||||
expect(backwards.getYDown()).toBe(false);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('get tile origin', function() {
|
||||
var layer;
|
||||
|
||||
beforeEach(function() {
|
||||
layer = new ol.layer.TileLayer();
|
||||
});
|
||||
|
||||
describe('with tileOriginX and tileOriginY', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setTileOrigin(1, 2);
|
||||
});
|
||||
|
||||
it('returns the expected origin', function() {
|
||||
var origin = layer.getTileOrigin();
|
||||
expect(origin).toEqual([1, 2]);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('with extent', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setExtent(new ol.Bounds(-180, -90, 180, 90));
|
||||
});
|
||||
|
||||
it('returns the expected origin', function() {
|
||||
var origin = layer.getTileOrigin();
|
||||
expect(origin).toEqual([-180, 90]);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('with tileOriginCorner and extent', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setExtent(new ol.Bounds(-180, -90, 180, 90));
|
||||
layer.setTileOriginCorner('tr');
|
||||
});
|
||||
|
||||
it('returns the expected origin', function() {
|
||||
var origin = layer.getTileOrigin();
|
||||
expect(origin).toEqual([180, 90]);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('with tileOriginCorner, without extent', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setTileOriginCorner('tr');
|
||||
});
|
||||
|
||||
it('throws an error or return null', function() {
|
||||
var origin;
|
||||
if (ol.error.VERBOSE_ERRORS) {
|
||||
expect(function() {
|
||||
origin = layer.getTileOrigin();
|
||||
}).toThrow();
|
||||
} else {
|
||||
expect(function() {
|
||||
origin = layer.getTileOrigin();
|
||||
}).not.toThrow();
|
||||
expect(origin).toBeNull();
|
||||
}
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('with bad tileOriginCorner', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setTileOriginCorner('foo');
|
||||
});
|
||||
|
||||
it('returns the expected origin', function() {
|
||||
if (ol.error.VERBOSE_ERRORS) {
|
||||
expect(function() {
|
||||
var origin = layer.getTileOrigin();
|
||||
}).toThrow();
|
||||
} else {
|
||||
expect(function() {
|
||||
var origin = layer.getTileOrigin();
|
||||
}).not.toThrow();
|
||||
}
|
||||
});
|
||||
|
||||
});
|
||||
});
|
||||
|
||||
describe('get resolutions', function() {
|
||||
var layer;
|
||||
|
||||
beforeEach(function() {
|
||||
layer = new ol.layer.TileLayer();
|
||||
});
|
||||
|
||||
describe('with resolutions set', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setResolutions([1, 0.5, 0.25]);
|
||||
});
|
||||
|
||||
it('returns the expected resolutions', function() {
|
||||
var resolutions = layer.getResolutions();
|
||||
expect(resolutions).toEqual([1, 0.5, 0.25]);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('with maxResolution and numZoomLevels set', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setMaxResolution(1);
|
||||
layer.setNumZoomLevels(3);
|
||||
});
|
||||
|
||||
it('returns the expected resolutions', function() {
|
||||
var resolutions = layer.getResolutions();
|
||||
expect(resolutions).toEqual([1, 0.5, 0.25]);
|
||||
});
|
||||
|
||||
});
|
||||
});
|
||||
|
||||
describe('get max resolution', function() {
|
||||
var layer;
|
||||
|
||||
beforeEach(function() {
|
||||
layer = new ol.layer.TileLayer();
|
||||
});
|
||||
|
||||
describe('with max resolution', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setMaxResolution(156543.03390625);
|
||||
});
|
||||
|
||||
it('returns the expected maxResolution', function() {
|
||||
var maxResolution = layer.getMaxResolution();
|
||||
expect(maxResolution).toEqual(156543.03390625);
|
||||
});
|
||||
});
|
||||
|
||||
describe('with projection', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setProjection(new ol.Projection("EPSG:3857"));
|
||||
});
|
||||
|
||||
it('returns the expected maxResolution', function() {
|
||||
var maxResolution = layer.getMaxResolution();
|
||||
expect(maxResolution).toEqual(156543.03390625);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('get data from the layer', function() {
|
||||
var layer;
|
||||
|
||||
beforeEach(function() {
|
||||
layer = new ol.layer.TileLayer();
|
||||
layer.setUrl('/{z}/{x}/{y}');
|
||||
layer.setResolutions([1, 0.5, 0.25]);
|
||||
layer.setTileOrigin(-128, 128);
|
||||
layer.setExtent(new ol.Bounds(-128, -128, 128, 128));
|
||||
// we need a TileLayer implementation, just
|
||||
// use duck-typing on the layer instance
|
||||
layer.getTileUrl = function(x, y, z) {
|
||||
return this.getUrl().replace('{x}', x + '')
|
||||
.replace('{y}', y + '')
|
||||
.replace('{z}', z + '');
|
||||
};
|
||||
});
|
||||
|
||||
describe('extent -128,-128,128,128, resolution 1', function() {
|
||||
|
||||
it('returns the expected data', function() {
|
||||
var tileset = layer.getData(
|
||||
new ol.Bounds(-128, -128, 128, 128), 1);
|
||||
|
||||
var tiles = tileset.getTiles();
|
||||
expect(tiles.length).toEqual(1);
|
||||
expect(tiles[0].length).toEqual(1);
|
||||
|
||||
var tile = tiles[0][0];
|
||||
expect(tile.getUrl()).toEqual('/0/0/0');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('extent -192,-192,192,192, resolution 1', function() {
|
||||
|
||||
it('returns the expected data', function() {
|
||||
var tileset = layer.getData(
|
||||
new ol.Bounds(-192, -192, 192, 192), 1);
|
||||
|
||||
var tiles = tileset.getTiles();
|
||||
expect(tiles.length).toEqual(1);
|
||||
expect(tiles[0].length).toEqual(1);
|
||||
|
||||
var tile = tiles[0][0];
|
||||
expect(tile.getUrl()).toEqual('/0/0/0');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('extent -128,-128,128,128, resolution 0.5', function() {
|
||||
|
||||
it('returns the expected data', function() {
|
||||
var tileset = layer.getData(
|
||||
new ol.Bounds(-128, -128, 128, 128), 0.5);
|
||||
|
||||
var tiles = tileset.getTiles();
|
||||
expect(tiles.length).toEqual(2);
|
||||
expect(tiles[0].length).toEqual(2);
|
||||
|
||||
var tile;
|
||||
|
||||
tile = tiles[0][0];
|
||||
expect(tile.getUrl()).toEqual('/1/0/0');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
|
||||
tile = tiles[0][1];
|
||||
expect(tile.getUrl()).toEqual('/1/1/0');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
|
||||
tile = tiles[1][0];
|
||||
expect(tile.getUrl()).toEqual('/1/0/1');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
|
||||
tile = tiles[1][1];
|
||||
expect(tile.getUrl()).toEqual('/1/1/1');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('extent -64,-64,64,64, resolution 0.5', function() {
|
||||
|
||||
it('returns the expected data', function() {
|
||||
var tileset = layer.getData(
|
||||
new ol.Bounds(-64, -64, 64, 64), 0.5);
|
||||
|
||||
var tiles = tileset.getTiles();
|
||||
expect(tiles.length).toEqual(2);
|
||||
expect(tiles[0].length).toEqual(2);
|
||||
|
||||
var tile;
|
||||
|
||||
tile = tiles[0][0];
|
||||
expect(tile.getUrl()).toEqual('/1/0/0');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
|
||||
tile = tiles[0][1];
|
||||
expect(tile.getUrl()).toEqual('/1/1/0');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
|
||||
tile = tiles[1][0];
|
||||
expect(tile.getUrl()).toEqual('/1/0/1');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
|
||||
tile = tiles[1][1];
|
||||
expect(tile.getUrl()).toEqual('/1/1/1');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('extent -96,32,-32,96, resolution 0.5', function() {
|
||||
|
||||
it('returns the expected data', function() {
|
||||
var tileset = layer.getData(
|
||||
new ol.Bounds(-96, 32, -32, 96), 0.5);
|
||||
|
||||
var tiles = tileset.getTiles();
|
||||
expect(tiles.length).toEqual(1);
|
||||
expect(tiles[0].length).toEqual(1);
|
||||
|
||||
var tile;
|
||||
|
||||
tile = tiles[0][0];
|
||||
expect(tile.getUrl()).toEqual('/1/0/0');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('extent -32,32,32,96, resolution 0.5', function() {
|
||||
|
||||
it('returns the expected data', function() {
|
||||
var tileset = layer.getData(
|
||||
new ol.Bounds(-32, 32, 32, 96), 0.5);
|
||||
|
||||
var tiles = tileset.getTiles();
|
||||
expect(tiles.length).toEqual(1);
|
||||
expect(tiles[0].length).toEqual(2);
|
||||
|
||||
var tile;
|
||||
|
||||
tile = tiles[0][0];
|
||||
expect(tile.getUrl()).toEqual('/1/0/0');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
|
||||
tile = tiles[0][1];
|
||||
expect(tile.getUrl()).toEqual('/1/1/0');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('extent 32,-32,96,32, resolution 0.5', function() {
|
||||
|
||||
it('returns the expected data', function() {
|
||||
var tileset = layer.getData(
|
||||
new ol.Bounds(32, -32, 96, 32), 0.5);
|
||||
|
||||
var tiles = tileset.getTiles();
|
||||
expect(tiles.length).toEqual(2);
|
||||
expect(tiles[0].length).toEqual(1);
|
||||
expect(tiles[1].length).toEqual(1);
|
||||
|
||||
var tile;
|
||||
|
||||
tile = tiles[0][0];
|
||||
expect(tile.getUrl()).toEqual('/1/1/0');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
|
||||
tile = tiles[1][0];
|
||||
expect(tile.getUrl()).toEqual('/1/1/1');
|
||||
expect(tile.getImg()).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('get a tile', function() {
|
||||
var layer;
|
||||
|
||||
beforeEach(function() {
|
||||
layer = new ol.layer.TileLayer();
|
||||
layer.setUrl('/{z}/{x}/{y}');
|
||||
layer.setResolutions([1, 0.5, 0.25]);
|
||||
layer.setTileOrigin(-128, 128);
|
||||
// we need a TileLayer implementation, just
|
||||
// use duck-typing on the layer instance
|
||||
layer.getTileUrl = function(x, y, z) {
|
||||
return this.getUrl().replace('{x}', x + '')
|
||||
.replace('{y}', y + '')
|
||||
.replace('{z}', z + '');
|
||||
};
|
||||
});
|
||||
|
||||
it('returns the expected tile', function() {
|
||||
var tile = layer.getTileForXYZ(1, 2, 2);
|
||||
expect(tile.getUrl()).toEqual('/2/1/2');
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('test x y validity', function() {
|
||||
var layer;
|
||||
|
||||
beforeEach(function() {
|
||||
layer = new ol.layer.TileLayer();
|
||||
layer.setTileOrigin(0, 0);
|
||||
layer.setResolutions([1, 0.5, 0.25]);
|
||||
});
|
||||
|
||||
describe('tile index goes right/down', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setXRight(true);
|
||||
layer.setYDown(true);
|
||||
});
|
||||
|
||||
describe('extent is right/down of origin', function() {
|
||||
|
||||
describe('extent and tile boundaries match', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setExtent(new ol.Bounds(128, -384, 384, -128));
|
||||
});
|
||||
|
||||
it('detects valid x y', function() {
|
||||
var v;
|
||||
v = layer.validXY(0, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(2, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(3, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 1, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(2, 1, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(3, 1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(2, 2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(3, 2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(2, 3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(3, 3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
});
|
||||
});
|
||||
|
||||
describe('extent and tile boundaries do not match', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setExtent(new ol.Bounds(192, -448, 448, -192));
|
||||
});
|
||||
|
||||
it('detects valid x y', function() {
|
||||
var v;
|
||||
v = layer.validXY(0, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(2, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(3, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(4, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 1, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(2, 1, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(3, 1, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(4, 1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(2, 2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(3, 2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(4, 2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(2, 3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(3, 3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(4, 3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(2, 4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(3, 4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(4, 4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('extent is left/up of origin', function() {
|
||||
|
||||
describe('extent and tile boundaries match', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setExtent(new ol.Bounds(-384, 128, -128, 384));
|
||||
});
|
||||
|
||||
it('detects valid x y', function() {
|
||||
var v;
|
||||
v = layer.validXY(-1, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-3, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-4, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-3, -2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-4, -2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-3, -3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-4, -3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-3, -4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-4, -4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
});
|
||||
});
|
||||
|
||||
describe('extent and tile boundaries do not match', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setExtent(new ol.Bounds(-448, 192, -192, 448));
|
||||
});
|
||||
|
||||
it('detects valid x y', function() {
|
||||
var v;
|
||||
v = layer.validXY(-1, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-3, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-4, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-5, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-3, -2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-4, -2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-5, -2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-3, -3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-4, -3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-5, -3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -4, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-3, -4, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-4, -4, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-5, -4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -5, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -5, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-3, -5, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-4, -5, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-5, -5, 1);
|
||||
expect(v).toBeFalsy();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('tile index goes left/up', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setXRight(false);
|
||||
layer.setYDown(false);
|
||||
});
|
||||
|
||||
describe('extent is right/down of origin', function() {
|
||||
|
||||
describe('extent and tile boundaries match', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setExtent(new ol.Bounds(128, -384, 384, -128));
|
||||
});
|
||||
|
||||
it('detects valid x y', function() {
|
||||
var v;
|
||||
v = layer.validXY(-1, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-3, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-4, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-3, -2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-4, -2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-3, -3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-4, -3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-3, -4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-4, -4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
});
|
||||
});
|
||||
|
||||
describe('extent and tile boundaries do not match', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setExtent(new ol.Bounds(192, -448, 448, -192));
|
||||
});
|
||||
|
||||
it('detects valid x y', function() {
|
||||
var v;
|
||||
v = layer.validXY(-1, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-3, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-4, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-5, -1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-3, -2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-4, -2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-5, -2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-3, -3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-4, -3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-5, -3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -4, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-3, -4, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-4, -4, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(-5, -4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(-1, -5, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-2, -5, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-3, -5, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-4, -5, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(-5, -5, 1);
|
||||
expect(v).toBeFalsy();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('extent is left/up of origin', function() {
|
||||
|
||||
describe('extent and tile boundaries match', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setExtent(new ol.Bounds(-384, 128, -128, 384));
|
||||
});
|
||||
|
||||
it('detects valid x y', function() {
|
||||
var v;
|
||||
v = layer.validXY(0, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(2, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(3, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 1, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(2, 1, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(3, 1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(2, 2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(3, 2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(2, 3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(3, 3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
});
|
||||
});
|
||||
|
||||
describe('extent and tile boundaries do not match', function() {
|
||||
|
||||
beforeEach(function() {
|
||||
layer.setExtent(new ol.Bounds(-448, 192, -192, 448));
|
||||
});
|
||||
|
||||
it('detects valid x y', function() {
|
||||
var v;
|
||||
v = layer.validXY(0, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(2, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(3, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(4, 0, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 1, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(2, 1, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(3, 1, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(4, 1, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(2, 2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(3, 2, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(4, 2, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(2, 3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(3, 3, 1);
|
||||
expect(v).toBeTruthy();
|
||||
v = layer.validXY(4, 3, 1);
|
||||
expect(v).toBeFalsy();
|
||||
|
||||
v = layer.validXY(0, 4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(1, 4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(2, 4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(3, 4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
v = layer.validXY(4, 4, 1);
|
||||
expect(v).toBeFalsy();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,27 +0,0 @@
|
||||
describe('ol.layer.WMS', function() {
|
||||
|
||||
describe('create a wms layer', function() {
|
||||
|
||||
it('returns an ol.layer.WMS instance', function() {
|
||||
var layer = new ol.layer.WMS();
|
||||
expect(layer instanceof ol.layer.WMS).toBe(true);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('get tile url', function() {
|
||||
var layer;
|
||||
beforeEach(function() {
|
||||
layer = new ol.layer.WMS('/wms', ['layer1', 'layer2']);
|
||||
layer.setResolutions([1, 0.5, 0.25]);
|
||||
layer.setTileOrigin(-128, 128);
|
||||
layer.setExtent(new ol.Bounds(-128, -128, 128, 128));
|
||||
layer.setProjection(new ol.Projection('EPSG:900913'));
|
||||
});
|
||||
it('returns a WMS GetMap URL', function() {
|
||||
var url = layer.getTileUrl(1, 2, 2);
|
||||
expect(url).toEqual('/wms?SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap&STYLES&FORMAT=image%2Fpng&WIDTH=256&HEIGHT=256&BBOX=-64%2C-64%2C0%2C0&LAYERS=layer1%2Clayer2&SRS=EPSG%3A900913');
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
@@ -1,12 +0,0 @@
|
||||
describe('ol.layer.XYZ', function() {
|
||||
|
||||
describe('create a xyz layer', function() {
|
||||
|
||||
it('returns an ol.layer.XYZ instance', function() {
|
||||
var layer = new ol.layer.XYZ();
|
||||
expect(layer instanceof ol.layer.XYZ).toBe(true);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
});
|
||||
@@ -1,229 +0,0 @@
|
||||
describe("ol.renderer.TileLayerRenderer", function() {
|
||||
|
||||
it("is supported in this environment", function() {
|
||||
// this will not always be true, but for now we expect it to be so
|
||||
expect(ol.renderer.TileLayerRenderer.isSupported()).toBe(true);
|
||||
});
|
||||
|
||||
it("handles tile layers", function() {
|
||||
var xyz = new ol.layer.XYZ();
|
||||
expect(ol.renderer.TileLayerRenderer.canRender(xyz)).toBe(true);
|
||||
});
|
||||
|
||||
it("doesn't handle arbitrary layers", function() {
|
||||
var layer = new ol.layer.Layer();
|
||||
expect(ol.renderer.TileLayerRenderer.canRender(layer)).toBe(false);
|
||||
});
|
||||
|
||||
it("returns a string type", function() {
|
||||
expect(ol.renderer.TileLayerRenderer.getType()).toBe("tile");
|
||||
});
|
||||
|
||||
describe("getPreferredResAndZ_", function() {
|
||||
var layer = new ol.layer.XYZ();
|
||||
var resolutions = [100, 80, 50, 10, 1, 0.1];
|
||||
layer.setResolutions(resolutions);
|
||||
|
||||
var container = document.createElement("div");
|
||||
var renderer = new ol.renderer.TileLayerRenderer(container, layer);
|
||||
|
||||
it("gets the max resolution", function() {
|
||||
var pair = renderer.getPreferredResAndZ_(100);
|
||||
expect(pair[0]).toBe(100);
|
||||
expect(pair[1]).toBe(0);
|
||||
});
|
||||
|
||||
it("gets the min resolution", function() {
|
||||
var pair = renderer.getPreferredResAndZ_(0.1);
|
||||
expect(pair[0]).toBe(0.1);
|
||||
expect(pair[1]).toBe(5);
|
||||
});
|
||||
|
||||
it("gets the max when bigger", function() {
|
||||
var pair = renderer.getPreferredResAndZ_(200);
|
||||
expect(pair[0]).toBe(100);
|
||||
expect(pair[1]).toBe(0);
|
||||
});
|
||||
|
||||
it("gets the min when smaller", function() {
|
||||
var pair = renderer.getPreferredResAndZ_(0.01);
|
||||
expect(pair[0]).toBe(0.1);
|
||||
expect(pair[1]).toBe(5);
|
||||
});
|
||||
|
||||
it("gets the first when in the middle", function() {
|
||||
var pair = renderer.getPreferredResAndZ_(90);
|
||||
expect(pair[0]).toBe(100);
|
||||
expect(pair[1]).toBe(0);
|
||||
});
|
||||
|
||||
it("gets the closer when elsewhere", function() {
|
||||
var pair = renderer.getPreferredResAndZ_(89);
|
||||
expect(pair[0]).toBe(80);
|
||||
expect(pair[1]).toBe(1);
|
||||
|
||||
pair = renderer.getPreferredResAndZ_(49);
|
||||
expect(pair[0]).toBe(50);
|
||||
expect(pair[1]).toBe(2);
|
||||
|
||||
pair = renderer.getPreferredResAndZ_(0.5);
|
||||
expect(pair[0]).toBe(0.1);
|
||||
expect(pair[1]).toBe(5);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe("getNormalizedTileCoord_", function() {
|
||||
var container = document.createElement("div");
|
||||
function str(coord) {
|
||||
return coord.x + "," + coord.y;
|
||||
}
|
||||
|
||||
describe("simple cases", function() {
|
||||
var layer = new ol.layer.TileLayer();
|
||||
layer.setResolutions([10]);
|
||||
layer.setTileOrigin(0, 0);
|
||||
var renderer = new ol.renderer.TileLayerRenderer(container, layer);
|
||||
|
||||
var loc, coord;
|
||||
|
||||
it("gets the first tile at the origin", function() {
|
||||
loc = new ol.Loc(0, 0);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 10);
|
||||
expect(str(coord)).toBe("0,0");
|
||||
});
|
||||
|
||||
it("gets one tile northwest of the origin", function() {
|
||||
loc = new ol.Loc(-1280, 1280);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 10);
|
||||
expect(str(coord)).toBe("-1,-1");
|
||||
});
|
||||
|
||||
it("gets one tile northeast of the origin", function() {
|
||||
loc = new ol.Loc(1280, 1280);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 10);
|
||||
expect(str(coord)).toBe("0,-1");
|
||||
});
|
||||
|
||||
it("gets one tile southeast of the origin", function() {
|
||||
loc = new ol.Loc(1280, -1280);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 10);
|
||||
expect(str(coord)).toBe("0,0");
|
||||
});
|
||||
|
||||
it("gets one tile southwest of the origin", function() {
|
||||
loc = new ol.Loc(-1280, -1280);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 10);
|
||||
expect(str(coord)).toBe("-1,0");
|
||||
});
|
||||
|
||||
it("gets the tile to the east when on the edge", function() {
|
||||
loc = new ol.Loc(2560, -1280);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 10);
|
||||
expect(str(coord)).toBe("1,0");
|
||||
});
|
||||
|
||||
it("gets the tile to the south when on the edge", function() {
|
||||
loc = new ol.Loc(1280, -2560);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 10);
|
||||
expect(str(coord)).toBe("0,1");
|
||||
});
|
||||
|
||||
it("pixels are top aligned to the origin", function() {
|
||||
loc = new ol.Loc(1280, -2559.999);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 10);
|
||||
expect(str(coord)).toBe("0,0");
|
||||
});
|
||||
|
||||
it("pixels are left aligned to the origin", function() {
|
||||
loc = new ol.Loc(2559.999, -1280);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 10);
|
||||
expect(str(coord)).toBe("0,0");
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe("fractional zoom", function() {
|
||||
var layer = new ol.layer.TileLayer();
|
||||
layer.setResolutions([1/3]);
|
||||
layer.setTileOrigin(0, 0);
|
||||
var renderer = new ol.renderer.TileLayerRenderer(container, layer);
|
||||
|
||||
var loc, coord;
|
||||
|
||||
/**
|
||||
These tests render at a resolution of 1. Because the layer's
|
||||
closest resolution is 1/3, the images are scaled by 1/3.
|
||||
In this scenario, every third tile will be one pixel wider when
|
||||
rendered (0,0 is normal; 1,0 is wider; 0,1 is taller; etc.)
|
||||
*/
|
||||
|
||||
it("gets the first tile at the origin", function() {
|
||||
loc = new ol.Loc(0, 0);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 1);
|
||||
expect(str(coord)).toBe("0,0");
|
||||
});
|
||||
|
||||
it("gets the 1,0 tile at 256/3,0", function() {
|
||||
loc = new ol.Loc(256/3, 0);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 1);
|
||||
expect(str(coord)).toBe("1,0");
|
||||
});
|
||||
|
||||
it("still gets the 1,0 tile at 512/3,0 - wider tile", function() {
|
||||
loc = new ol.Loc(512/3, 0);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 1);
|
||||
expect(str(coord)).toBe("1,0");
|
||||
});
|
||||
|
||||
it("gets the 2,0 tile at 513/3,0", function() {
|
||||
loc = new ol.Loc(513/3, 0);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 1);
|
||||
expect(str(coord)).toBe("2,0");
|
||||
});
|
||||
|
||||
it("gets the 3,0 tile at 768/3,0", function() {
|
||||
loc = new ol.Loc(768/3, 0);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 1);
|
||||
expect(str(coord)).toBe("3,0");
|
||||
});
|
||||
|
||||
it("gets the 4,0 tile at 1024/3,0", function() {
|
||||
loc = new ol.Loc(1024/3, 0);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 1);
|
||||
expect(str(coord)).toBe("4,0");
|
||||
});
|
||||
|
||||
it("still gets the 4,0 tile at 1280/3,0 - wider tile", function() {
|
||||
loc = new ol.Loc(1280/3, 0);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 1);
|
||||
expect(str(coord)).toBe("4,0");
|
||||
});
|
||||
|
||||
it("gets the 5,0 tile at 1281/3,0", function() {
|
||||
loc = new ol.Loc(1281/3, 0);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 1);
|
||||
expect(str(coord)).toBe("5,0");
|
||||
});
|
||||
|
||||
it("gets the 0,1 tile at 0,-256/3", function() {
|
||||
loc = new ol.Loc(0,-256/3);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 1);
|
||||
expect(str(coord)).toBe("0,1");
|
||||
});
|
||||
|
||||
it("still gets the 0,1 tile at 0,-512/3 - taller tile", function() {
|
||||
loc = new ol.Loc(0,-512/3);
|
||||
coord = renderer.getNormalizedTileCoord_(loc, 1);
|
||||
expect(str(coord)).toBe("0,1");
|
||||
});
|
||||
|
||||
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
|
||||
|
||||
});
|
||||
|
||||
@@ -1,9 +0,0 @@
|
||||
describe("ol.renderer.WebGL", function() {
|
||||
|
||||
it("is supported in this environment", function() {
|
||||
// this will not always be true, but for now we expect it to be so
|
||||
expect(ol.renderer.WebGL.isSupported()).toBe(true);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user