openlayers/tests/Map.html

   1 <html>
   2 <head>
   3   <script src="../lib/OpenLayers.js"></script>
   4   <script type="text/javascript">
   5
   6     var isMozilla = (navigator.userAgent.indexOf("compatible") == -1);
   7     var map;
   8
   9     function test_Map_constructor (t) {
  10         t.plan( 11 );
  11
  12         map = new OpenLayers.Map('map');
  13         var baseLayer = new OpenLayers.Layer.WMS("Test Layer",
  14             "http://octo.metacarta.com/cgi-bin/mapserv?",
  15             {map: "/mapdata/vmap_wms.map", layers: "basic"});
  16         map.addLayer(baseLayer);
  17
  18         t.ok( OpenLayers.Element.hasClass(map.div, "olMap"), "Map div has olMap class");
  19
  20         t.ok( map instanceof OpenLayers.Map, "new OpenLayers.Map returns object" );
  21         if (!isMozilla) {
  22             t.ok( true, "skipping element test outside of Mozilla");
  23             t.ok( true, "skipping element test outside of Mozilla");
  24             t.ok( true, "skipping element test outside of Mozilla");
  25         } else {
  26             t.ok( map.div instanceof HTMLDivElement, "map.div is an HTMLDivElement" );
  27             t.ok( map.viewPortDiv instanceof HTMLDivElement, "map.viewPortDiv is an HTMLDivElement" );
  28             t.ok( map.layerContainerDiv instanceof HTMLDivElement, "map.layerContainerDiv is an HTMLDivElement" );
  29         }
  30         t.ok( map.layers instanceof Array, "map.layers is an Array" );
  31         t.ok( map.controls instanceof Array, "map.controls is an Array" );
  32         t.eq( map.controls.length, 4, "Default map has 4 controls." );
  33         t.ok( map.events instanceof OpenLayers.Events, "map.events is an OpenLayers.Events" );
  34         t.ok( map.getMaxExtent() instanceof OpenLayers.Bounds, "map.maxExtent is an OpenLayers.Bounds" );
  35         t.ok( map.getNumZoomLevels() > 0, "map has a default numZoomLevels" );
  36     }
  37
  38     function test_Map_constructor_late_rendering(t) {
  39         t.plan( 4 );
  40
  41         map = new OpenLayers.Map();
  42         var baseLayer = new OpenLayers.Layer.WMS("Test Layer",
  43             "http://octo.metacarta.com/cgi-bin/mapserv?",
  44             {map: "/mapdata/vmap_wms.map", layers: "basic"});
  45         map.addLayer(baseLayer);
  46
  47         t.ok(map.div != null, "Map has a div even though none was specified.");
  48         t.ok(map.viewPortDiv.parentNode == map.div, "Map is attached to a temporary div that holds the viewPortDiv.");
  49
  50         var mapDiv = document.getElementById("map");
  51         // clean up the effects of other tests
  52         while(OpenLayers.Element.hasClass(mapDiv, "olMap")) {
  53             OpenLayers.Element.removeClass(mapDiv, "olMap");
  54         }
  55         map.render(mapDiv); // Can also take a string.
  56
  57         t.ok(map.div == mapDiv, "Map is now rendered to the 'map' div.")
  58         t.ok( OpenLayers.Element.hasClass(map.div, "olMap"), "Map div has olMap class");
  59     }
  60
  61     function test_Map_constructor_renderTo(t) {
  62         t.plan( 1 );
  63
  64         map = new OpenLayers.Map({
  65             div: "map"
  66         });
  67         var baseLayer = new OpenLayers.Layer.WMS("Test Layer",
  68             "http://octo.metacarta.com/cgi-bin/mapserv?",
  69             {map: "/mapdata/vmap_wms.map", layers: "basic"});
  70         map.addLayer(baseLayer);
  71
  72         var mapDiv = document.getElementById("map");
  73         t.ok(map.div == mapDiv, "Map is rendered to the 'map' div.")
  74     }
  75
  76     function test_Map_setOptions(t) {
  77         t.plan(2);
  78         map = new OpenLayers.Map('map', {maxExtent: new OpenLayers.Bounds(100, 200, 300, 400)});
  79         map.setOptions({theme: 'foo'});
  80
  81         t.eq(map.theme, 'foo', "theme is correctly set by setOptions");
  82         t.ok(map.maxExtent.equals(new OpenLayers.Bounds(100, 200, 300, 400)),
  83              "maxExtent is correct after calling setOptions");
  84     }
  85
  86     function test_Map_add_layers(t) {
  87         t.plan(6);
  88         map = new OpenLayers.Map('map');
  89         var layer1 = new OpenLayers.Layer.WMS("Layer 1",
  90             "http://octo.metacarta.com/cgi-bin/mapserv?",
  91             {map: "/mapdata/vmap_wms.map", layers: "basic"});
  92         var layer2 = new OpenLayers.Layer.WMS("Layer 2",
  93             "http://wms.jpl.nasa.gov/wms.cgi", {layers: "modis,global_mosaic"});
  94         // this uses map.addLayer internally
  95         map.addLayers([layer1, layer2])
  96         t.eq( map.layers.length, 2, "map has exactly two layers" );
  97         t.ok( map.layers[0] === layer1, "1st layer is layer1" );
  98         t.ok( map.layers[1] === layer2, "2nd layer is layer2" );
  99         t.ok( layer1.map === map, "layer.map is map" );
 100         t.eq( parseInt(layer1.div.style.zIndex), map.Z_INDEX_BASE['BaseLayer'],
 101                 "layer1 zIndex is set" );
 102         t.eq( parseInt(layer2.div.style.zIndex), map.Z_INDEX_BASE['BaseLayer'] + 5,
 103                 "layer2 zIndex is set" );
 104     }
 105
 106     function test_Map_options(t) {
 107         t.plan(3);
 108         map = new OpenLayers.Map('map', {numZoomLevels: 6, maxResolution: 3.14159, theme: 'foo'});
 109         t.eq( map.numZoomLevels, 6, "map.numZoomLevels set correctly via options hashtable" );
 110         t.eq( map.maxResolution, 3.14159, "map.maxResolution set correctly via options hashtable" );
 111         t.eq( map.theme, 'foo', "map theme set correctly." );
 112     }
 113
 114     function test_eventListeners(t) {
 115         t.plan(1);
 116
 117         var method = OpenLayers.Events.prototype.on;
 118         // test that events.on is called at map construction
 119         var options = {
 120             eventListeners: {foo: "bar"},
 121             controls: []
 122         };
 123         OpenLayers.Events.prototype.on = function(obj) {
 124             t.eq(obj, options.eventListeners, "events.on called with eventListeners");
 125         }
 126         var map = new OpenLayers.Map('map', options);
 127         OpenLayers.Events.prototype.on = method;
 128         map.destroy();
 129
 130         // if events.on is called again, this will fail due to an extra test
 131         // test map without eventListeners
 132         OpenLayers.Events.prototype.on = function(obj) {
 133             t.fail("events.on called without eventListeners");
 134         }
 135         var map2 = new OpenLayers.Map("map", {controls: []});
 136         OpenLayers.Events.prototype.on = method;
 137         map2.destroy();
 138     }
 139
 140     function test_Map_center(t) {
 141         t.plan(8);
 142         map = new OpenLayers.Map('map');
 143         var baseLayer = new OpenLayers.Layer.WMS("Test Layer",
 144             "http://octo.metacarta.com/cgi-bin/mapserv?",
 145             {map: "/mapdata/vmap_wms.map", layers: "basic"} );
 146         map.addLayer(baseLayer);
 147         var ll = new OpenLayers.LonLat(2,1);
 148         map.setCenter(ll, 0);
 149         t.ok( map.getCenter() instanceof OpenLayers.LonLat, "map.getCenter returns a LonLat");
 150         t.eq( map.getZoom(), 0, "map.zoom is correct after calling setCenter");
 151         t.ok( map.getCenter().equals(ll), "map center is correct after calling setCenter");
 152         map.zoomIn();
 153         t.eq( map.getZoom(), 1, "map.zoom is correct after calling setCenter,zoom in");
 154         t.ok( map.getCenter().equals(ll), "map center is correct after calling setCenter, zoom in");
 155         map.zoomOut();
 156         t.eq( map.getZoom(), 0, "map.zoom is correct after calling setCenter,zoom in, zoom out");
 157
 158         map.zoomTo(5);
 159         t.eq( map.getZoom(), 5, "map.zoom is correct after calling zoomTo" );
 160
 161     /**
 162         map.zoomToMaxExtent();
 163         t.eq( map.getZoom(), 2, "map.zoom is correct after calling zoomToMaxExtent" );
 164         var lonlat = map.getCenter();
 165         var zero = new OpenLayers.LonLat(0, 0);
 166         t.ok( lonlat.equals(zero), "map center is correct after calling zoomToFullExtent" );
 167     */
 168
 169         map.getCenter().lon = 10;
 170         t.ok( map.getCenter().equals(ll), "map.getCenter returns a clone of map.center");
 171     }
 172
 173     function test_Map_zoomend_event (t) {
 174         t.plan(2);
 175
 176         map = new OpenLayers.Map('map');
 177         var baseLayer = new OpenLayers.Layer.WMS("Test Layer",
 178             "http://octo.metacarta.com/cgi-bin/mapserv?",
 179             {map: "/mapdata/vmap_wms.map", layers: "basic"});
 180         map.addLayer(baseLayer);
 181         map.events.register("zoomend", {count: 0}, function() {
 182             this.count++;
 183             t.ok(true, "zoomend event was triggered " + this.count + " times");
 184             });
 185         map.setCenter(new OpenLayers.LonLat(2, 1), 0);
 186         map.zoomIn();
 187         map.zoomOut();
 188     }
 189
 190     function test_Map_add_remove_popup (t) {
 191         t.plan(4);
 192
 193         map = new OpenLayers.Map('map');
 194         var baseLayer = new OpenLayers.Layer.WMS("Test Layer",
 195             "http://octo.metacarta.com/cgi-bin/mapserv?",
 196             {map: "/mapdata/vmap_wms.map", layers: "basic"});
 197         map.addLayer(baseLayer);
 198
 199         var popup = new OpenLayers.Popup("chicken",
 200                                          new OpenLayers.LonLat(0,0),
 201                                          new OpenLayers.Size(200,200));
 202         map.setCenter(new OpenLayers.LonLat(0, 0), 0);
 203
 204         map.addPopup(popup);
 205         var pIndex = OpenLayers.Util.indexOf(map.popups, popup);
 206         t.eq(pIndex, 0, "popup successfully added to Map's internal popups array");
 207
 208         var nodes = map.layerContainerDiv.childNodes;
 209
 210         var found = false;
 211         for (var i=0; i < nodes.length; i++) {
 212             if (nodes.item(i) == popup.div) {
 213                 found = true;
 214                 break;
 215             }
 216         }
 217         t.ok(found, "popup.div successfully added to the map's viewPort");
 218
 219
 220         map.removePopup(popup);
 221         var pIndex = OpenLayers.Util.indexOf(map.popups, popup);
 222         t.eq(pIndex, -1, "popup successfully removed from Map's internal popups array");
 223
 224         var found = false;
 225         for (var i=0; i < nodes.length; i++) {
 226             if (nodes.item(i) == popup.div) {
 227                 found = true;
 228                 break;
 229             }
 230         }
 231         t.ok(!found, "popup.div successfully removed from the map's viewPort");
 232     }
 233
 234     function test_Map_add_popup_exclusive(t) {
 235         t.plan(2);
 236
 237         map = new OpenLayers.Map('map');
 238         var baseLayer = new OpenLayers.Layer.WMS("Test Layer",
 239             "http://octo.metacarta.com/cgi-bin/mapserv?",
 240             {map: "/mapdata/vmap_wms.map", layers: "basic"});
 241         map.addLayer(baseLayer);
 242
 243         map.setCenter(new OpenLayers.LonLat(0, 0), 0);
 244
 245         for (var i = 0; i < 10; i++) {
 246             var popup = new OpenLayers.Popup("chicken",
 247                                              new OpenLayers.LonLat(0,0),
 248                                              new OpenLayers.Size(200,200));
 249             map.addPopup(popup);
 250         }
 251         t.eq(map.popups.length, 10, "addPopup non exclusive mode works");
 252
 253         var popup = new OpenLayers.Popup("chicken",
 254                                          new OpenLayers.LonLat(0,0),
 255                                          new OpenLayers.Size(200,200));
 256         map.addPopup(popup, true);
 257         t.eq(map.popups.length, 1, "addPopup exclusive mode works");
 258     }
 259
 260
 261 /***  THIS IS A GOOD TEST, BUT IT SHOULD BE MOVED TO WMS.
 262  *     Also, it won't work until we figure out the viewSize bug
 263
 264     function 08_Map_px_lonlat_translation (t) {
 265         t.plan( 6 );
 266         map = new OpenLayers.Map('map');
 267         var baseLayer = new OpenLayers.Layer.WMS("Test Layer",
 268             "http://octo.metacarta.com/cgi-bin/mapserv?",
 269             {map: "/mapdata/vmap_wms.map", layers: "basic"});
 270         map.addLayer(baseLayer);
 271         map.setCenter(new OpenLayers.LonLat(0, 0), 0);
 272
 273         var pixel = new OpenLayers.Pixel(50,150);
 274         var lonlat = map.getLonLatFromViewPortPx(pixel);
 275         t.ok( lonlat instanceof OpenLayers.LonLat, "getLonLatFromViewPortPx returns valid OpenLayers.LonLat" );
 276
 277         var newPixel = map.getViewPortPxFromLonLat(lonlat);
 278         t.ok( newPixel instanceof OpenLayers.Pixel, "getViewPortPxFromLonLat returns valid OpenLayers.Pixel" );
 279
 280         // WARNING!!!  I'm faily sure that the following test's validity
 281         //             depends highly on rounding and the resolution. For now,
 282         //             in the default case, it seems to work. This may not
 283         //             always be so.
 284         t.ok( newPixel.equals(pixel), "Translation to pixel and back to lonlat is consistent");
 285
 286         lonlat = map.getLonLatFromPixel(pixel);
 287         t.ok( lonlat instanceof OpenLayers.LonLat, "getLonLatFromPixel returns valid OpenLayers.LonLat" );
 288
 289         newPixel = map.getPixelFromLonLat(lonlat);
 290         t.ok( newPixel instanceof OpenLayers.Pixel, "getPixelFromLonLat returns valid OpenLayers.Pixel" );
 291
 292         t.ok( newPixel.equals(pixel), "2nd translation to pixel and back to lonlat is consistent");
 293     }
 294  */
 295
 296     function test_Map_isValidLonLat(t) {
 297         t.plan( 3 );
 298
 299         map = new OpenLayers.Map('map');
 300         layer = new OpenLayers.Layer.WMS('Test Layer',
 301                     "http://octo.metacarta.com/cgi-bin/mapserv",
 302                     {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'},
 303                     {maxExtent: new OpenLayers.Bounds(33861, 717605, 330846, 1019656), maxResolution: 296985/1024, projection:"EPSG:2805" } );
 304         map.addLayer(layer);
 305
 306         t.ok( !map.isValidLonLat(null), "null lonlat is not valid" );
 307         t.ok( map.isValidLonLat(new OpenLayers.LonLat(33862, 717606)), "lonlat outside max extent is valid" );
 308         t.ok( !map.isValidLonLat(new OpenLayers.LonLat(10, 10)), "lonlat outside max extent is not valid" );
 309     }
 310
 311     function test_Map_getLayer(t) {
 312         var numLayers = 3;
 313         t.plan( numLayers + 1 );
 314
 315         var m = {
 316             layers: []
 317         };
 318
 319         for(var i = 0; i < numLayers; i++) {
 320             m.layers.push( { 'id': i } );
 321         }
 322
 323         for(var i = 0; i < numLayers; i++) {
 324             var layer = OpenLayers.Map.prototype.getLayer.apply(m, [i]);
 325             t.ok( layer == m.layers[i], "getLayer correctly returns layer " + i);
 326         }
 327
 328         var gotLayer = OpenLayers.Map.prototype.getLayer.apply(m, ["chicken"]);
 329         t.ok( gotLayer == null, "getLayer correctly returns null when layer not found");
 330     }
 331
 332     function test_Map_getLayersBy(t) {
 333
 334         var map = {
 335             getBy: OpenLayers.Map.prototype.getBy,
 336             getLayersBy: OpenLayers.Map.prototype.getLayersBy,
 337             layers: [
 338                 {foo: "foo", id: Math.random()},
 339                 {foo: "bar", id: Math.random()},
 340                 {foo: "foobar", id: Math.random()},
 341                 {foo: "foo bar", id: Math.random()},
 342                 {foo: "foo", id: Math.random()}
 343             ]
 344         };
 345
 346         var cases = [
 347             {
 348                 got: map.getLayersBy("foo", "foo"),
 349                 expected: [map.layers[0], map.layers[4]],
 350                 message: "(string literal) got two layers matching foo"
 351             }, {
 352                 got: map.getLayersBy("foo", "bar"),
 353                 expected: [map.layers[1]],
 354                 message: "(string literal) got one layer matching foo"
 355             }, {
 356                 got: map.getLayersBy("foo", "barfoo"),
 357                 expected: [],
 358                 message: "(string literal) got empty array for no foo match"
 359             }, {
 360                 got: map.getLayersBy("foo", /foo/),
 361                 expected: [map.layers[0], map.layers[2], map.layers[3], map.layers[4]],
 362                 message: "(regexp literal) got three layers containing string"
 363             }, {
 364                 got: map.getLayersBy("foo", /foo$/),
 365                 expected: [map.layers[0], map.layers[4]],
 366                 message: "(regexp literal) got three layers ending with string"
 367             }, {
 368                 got: map.getLayersBy("foo", /\s/),
 369                 expected: [map.layers[3]],
 370                 message: "(regexp literal) got layer containing space"
 371             }, {
 372                 got: map.getLayersBy("foo", new RegExp("BAR", "i")),
 373                 expected: [map.layers[1], map.layers[2], map.layers[3]],
 374                 message: "(regexp object) got layers ignoring case"
 375             }, {
 376                 got: map.getLayersBy("foo", {test: function(str) {return str.length > 3;}}),
 377                 expected: [map.layers[2], map.layers[3]],
 378                 message: "(custom object) got layers with foo length greater than 3"
 379             }
 380         ];
 381         t.plan(cases.length);
 382         for(var i=0; i<cases.length; ++i) {
 383             t.eq(cases[i].got, cases[i].expected, cases[i].message);
 384         }
 385
 386     }
 387
 388     function test_Map_getLayersByName(t) {
 389
 390         var map = {
 391             getBy: OpenLayers.Map.prototype.getBy,
 392             getLayersBy: OpenLayers.Map.prototype.getLayersBy,
 393             getLayersByName: OpenLayers.Map.prototype.getLayersByName,
 394             layers: [
 395                 {name: "foo", id: Math.random()},
 396                 {name: "bar", id: Math.random()},
 397                 {name: "foobar", id: Math.random()},
 398                 {name: "foo bar", id: Math.random()},
 399                 {name: "foo", id: Math.random()}
 400             ]
 401         };
 402
 403         var cases = [
 404             {
 405                 got: map.getLayersByName("foo"),
 406                 expected: [map.layers[0], map.layers[4]],
 407                 message: "(string literal) got two layers matching name"
 408             }, {
 409                 got: map.getLayersByName("bar"),
 410                 expected: [map.layers[1]],
 411                 message: "(string literal) got one layer matching name"
 412             }, {
 413                 got: map.getLayersByName("barfoo"),
 414                 expected: [],
 415                 message: "(string literal) got empty array for no match"
 416             }, {
 417                 got: map.getLayersByName(/foo/),
 418                 expected: [map.layers[0], map.layers[2], map.layers[3], map.layers[4]],
 419                 message: "(regexp literal) got three layers containing string"
 420             }, {
 421                 got: map.getLayersByName(/foo$/),
 422                 expected: [map.layers[0], map.layers[4]],
 423                 message: "(regexp literal) got three layers ending with string"
 424             }, {
 425                 got: map.getLayersByName(/\s/),
 426                 expected: [map.layers[3]],
 427                 message: "(regexp literal) got layer containing space"
 428             }, {
 429                 got: map.getLayersByName(new RegExp("BAR", "i")),
 430                 expected: [map.layers[1], map.layers[2], map.layers[3]],
 431                 message: "(regexp object) got layers ignoring case"
 432             }, {
 433                 got: map.getLayersByName({test: function(str) {return str.length > 3;}}),
 434                 expected: [map.layers[2], map.layers[3]],
 435                 message: "(custom object) got layers with name length greater than 3"
 436             }
 437         ];
 438         t.plan(cases.length);
 439         for(var i=0; i<cases.length; ++i) {
 440             t.eq(cases[i].got, cases[i].expected, cases[i].message);
 441         }
 442
 443     }
 444
 445     function test_Map_getLayersByClass(t) {
 446
 447         var map = {
 448             getBy: OpenLayers.Map.prototype.getBy,
 449             getLayersBy: OpenLayers.Map.prototype.getLayersBy,
 450             getLayersByClass: OpenLayers.Map.prototype.getLayersByClass,
 451             layers: [
 452                 {CLASS_NAME: "foo", id: Math.random()},
 453                 {CLASS_NAME: "bar", id: Math.random()},
 454                 {CLASS_NAME: "foobar", id: Math.random()},
 455                 {CLASS_NAME: "foo bar", id: Math.random()},
 456                 {CLASS_NAME: "foo", id: Math.random()}
 457             ]
 458         };
 459
 460         var cases = [
 461             {
 462                 got: map.getLayersByClass("foo"),
 463                 expected: [map.layers[0], map.layers[4]],
 464                 message: "(string literal) got two layers matching type"
 465             }, {
 466                 got: map.getLayersByClass("bar"),
 467                 expected: [map.layers[1]],
 468                 message: "(string literal) got one layer matching type"
 469             }, {
 470                 got: map.getLayersByClass("barfoo"),
 471                 expected: [],
 472                 message: "(string literal) got empty array for no match"
 473             }, {
 474                 got: map.getLayersByClass(/foo/),
 475                 expected: [map.layers[0], map.layers[2], map.layers[3], map.layers[4]],
 476                 message: "(regexp literal) got three layers containing string"
 477             }, {
 478                 got: map.getLayersByClass(/foo$/),
 479                 expected: [map.layers[0], map.layers[4]],
 480                 message: "(regexp literal) got three layers ending with string"
 481             }, {
 482                 got: map.getLayersByClass(/\s/),
 483                 expected: [map.layers[3]],
 484                 message: "(regexp literal) got layer containing space"
 485             }, {
 486                 got: map.getLayersByClass(new RegExp("BAR", "i")),
 487                 expected: [map.layers[1], map.layers[2], map.layers[3]],
 488                 message: "(regexp object) got layers ignoring case"
 489             }, {
 490                 got: map.getLayersByClass({test: function(str) {return str.length > 3;}}),
 491                 expected: [map.layers[2], map.layers[3]],
 492                 message: "(custom object) got layers with type length greater than 3"
 493             }
 494         ];
 495         t.plan(cases.length);
 496         for(var i=0; i<cases.length; ++i) {
 497             t.eq(cases[i].got, cases[i].expected, cases[i].message);
 498         }
 499
 500     }
 501
 502     function test_Map_getControlsBy(t) {
 503
 504         var map = {
 505             getBy: OpenLayers.Map.prototype.getBy,
 506             getControlsBy: OpenLayers.Map.prototype.getControlsBy,
 507             controls: [
 508                 {foo: "foo", id: Math.random()},
 509                 {foo: "bar", id: Math.random()},
 510                 {foo: "foobar", id: Math.random()},
 511                 {foo: "foo bar", id: Math.random()},
 512                 {foo: "foo", id: Math.random()}
 513             ]
 514         };
 515
 516         var cases = [
 517             {
 518                 got: map.getControlsBy("foo", "foo"),
 519                 expected: [map.controls[0], map.controls[4]],
 520                 message: "(string literal) got two controls matching foo"
 521             }, {
 522                 got: map.getControlsBy("foo", "bar"),
 523                 expected: [map.controls[1]],
 524                 message: "(string literal) got one control matching foo"
 525             }, {
 526                 got: map.getControlsBy("foo", "barfoo"),
 527                 expected: [],
 528                 message: "(string literal) got empty array for no foo match"
 529             }, {
 530                 got: map.getControlsBy("foo", /foo/),
 531                 expected: [map.controls[0], map.controls[2], map.controls[3], map.controls[4]],
 532                 message: "(regexp literal) got three controls containing string"
 533             }, {
 534                 got: map.getControlsBy("foo", /foo$/),
 535                 expected: [map.controls[0], map.controls[4]],
 536                 message: "(regexp literal) got three controls ending with string"
 537             }, {
 538                 got: map.getControlsBy("foo", /\s/),
 539                 expected: [map.controls[3]],
 540                 message: "(regexp literal) got control containing space"
 541             }, {
 542                 got: map.getControlsBy("foo", new RegExp("BAR", "i")),
 543                 expected: [map.controls[1], map.controls[2], map.controls[3]],
 544                 message: "(regexp object) got layers ignoring case"
 545             }, {
 546                 got: map.getControlsBy("foo", {test: function(str) {return str.length > 3;}}),
 547                 expected: [map.controls[2], map.controls[3]],
 548                 message: "(custom object) got controls with foo length greater than 3"
 549             }
 550         ];
 551         t.plan(cases.length);
 552         for(var i=0; i<cases.length; ++i) {
 553             t.eq(cases[i].got, cases[i].expected, cases[i].message);
 554         }
 555
 556     }
 557
 558     function test_Map_getControlsByClass(t) {
 559
 560         var map = {
 561             getBy: OpenLayers.Map.prototype.getBy,
 562             getControlsBy: OpenLayers.Map.prototype.getControlsBy,
 563             getControlsByClass: OpenLayers.Map.prototype.getControlsByClass,
 564             controls: [
 565                 {CLASS_NAME: "foo", id: Math.random()},
 566                 {CLASS_NAME: "bar", id: Math.random()},
 567                 {CLASS_NAME: "foobar", id: Math.random()},
 568                 {CLASS_NAME: "foo bar", id: Math.random()},
 569                 {CLASS_NAME: "foo", id: Math.random()}
 570             ]
 571         };
 572
 573         var cases = [
 574             {
 575                 got: map.getControlsByClass("foo"),
 576                 expected: [map.controls[0], map.controls[4]],
 577                 message: "(string literal) got two controls matching type"
 578             }, {
 579                 got: map.getControlsByClass("bar"),
 580                 expected: [map.controls[1]],
 581                 message: "(string literal) got one control matching type"
 582             }, {
 583                 got: map.getControlsByClass("barfoo"),
 584                 expected: [],
 585                 message: "(string literal) got empty array for no match"
 586             }, {
 587                 got: map.getControlsByClass(/foo/),
 588                 expected: [map.controls[0], map.controls[2], map.controls[3], map.controls[4]],
 589                 message: "(regexp literal) got three controls containing string"
 590             }, {
 591                 got: map.getControlsByClass(/foo$/),
 592                 expected: [map.controls[0], map.controls[4]],
 593                 message: "(regexp literal) got three controls ending with string"
 594             }, {
 595                 got: map.getControlsByClass(/\s/),
 596                 expected: [map.controls[3]],
 597                 message: "(regexp literal) got control containing space"
 598             }, {
 599                 got: map.getControlsByClass(new RegExp("BAR", "i")),
 600                 expected: [map.controls[1], map.controls[2], map.controls[3]],
 601                 message: "(regexp object) got controls ignoring case"
 602             }, {
 603                 got: map.getControlsByClass({test: function(str) {return str.length > 3;}}),
 604                 expected: [map.controls[2], map.controls[3]],
 605                 message: "(custom object) got controls with type length greater than 3"
 606             }
 607         ];
 608         t.plan(cases.length);
 609         for(var i=0; i<cases.length; ++i) {
 610             t.eq(cases[i].got, cases[i].expected, cases[i].message);
 611         }
 612
 613     }
 614
 615     function test_Map_double_addLayer(t) {
 616         t.plan( 1 );
 617
 618         map = new OpenLayers.Map($('map'));
 619         layer = new OpenLayers.Layer.WMS('Test Layer',
 620                     "http://octo.metacarta.com/cgi-bin/mapserv",
 621                     {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'}
 622                     );
 623
 624         map.addLayers([layer,layer]);
 625
 626         t.eq( map.layers.length, 1, "Map does not allow double adding of layers." );
 627
 628     }
 629
 630     function test_Map_setBaseLayer(t) {
 631         t.plan( 4 );
 632
 633         map = new OpenLayers.Map('map');
 634
 635         var wmslayer = new OpenLayers.Layer.WMS('Test Layer',
 636                     "http://octo.metacarta.com/cgi-bin/mapserv",
 637                     {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'},
 638                     {maxExtent: new OpenLayers.Bounds(33861, 717605, 330846, 1019656), maxResolution: 296985/1024, projection:"EPSG:2805" } );
 639
 640         var wmslayer2 = new OpenLayers.Layer.WMS('Test Layer2',
 641                     "http://octo.metacarta.com/cgi-bin/mapserv",
 642                     {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'},
 643                     {maxExtent: new OpenLayers.Bounds(33861, 717605, 330846, 1019656), maxResolution: 296985/1024, projection:"EPSG:2805" } );
 644
 645         map.addLayers([wmslayer, wmslayer2]);
 646
 647         t.ok(map.baseLayer == wmslayer, "default base layer is first one added");
 648
 649         map.setBaseLayer(null);
 650         t.ok(map.baseLayer == wmslayer, "setBaseLayer on null object does nothing (and does not break)");
 651
 652         map.setBaseLayer("chicken");
 653         t.ok(map.baseLayer == wmslayer, "setBaseLayer on non-layer object does nothing (and does not break)");
 654
 655         map.setBaseLayer(wmslayer2);
 656         t.ok(map.baseLayer == wmslayer2, "setbaselayer correctly sets 'baseLayer' property");
 657     }
 658
 659     function test_Map_removeLayer(t) {
 660         t.plan(1);
 661         var f = function() {};
 662         var layers = [
 663             {name: "fee", removeMap: f},
 664             {name: "fi", removeMap: f},
 665             {name: "fo", removeMap: f},
 666             {name: "fum", removeMap: f}
 667         ];
 668         var map = {
 669             layers: layers,
 670             baseLayer: layers[0],
 671             layerContainerDiv: {removeChild: f},
 672             events: {triggerEvent: f},
 673             resetLayersZIndex: function() {}
 674         };
 675         OpenLayers.Map.prototype.removeLayer.apply(map, [map.baseLayer, false]);
 676         t.eq(map.baseLayer, null,
 677              "removing the baselayer sets baseLayer to null");
 678     }
 679
 680     function test_Map_removeLayer_res(t) {
 681         t.plan(2);
 682
 683         map = new OpenLayers.Map('map');
 684
 685         var layer0 = new OpenLayers.Layer.WMS(
 686             'Test Layer 0',
 687             "http://octo.metacarta.com/cgi-bin/mapserv",
 688             {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'},
 689             {resolutions: [4, 2, 1]}
 690         );
 691
 692         var layer1 = new OpenLayers.Layer.WMS(
 693             'Test Layer 1',
 694             "http://octo.metacarta.com/cgi-bin/mapserv",
 695             {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'},
 696             {resolutions: [4, 2]}
 697         );
 698
 699         map.addLayers([layer0, layer1]);
 700         map.zoomToMaxExtent();
 701         map.zoomTo(2);
 702         t.eq(map.getResolution(), layer0.resolutions[2],
 703              "correct resolution before removal");
 704         map.removeLayer(layer0);
 705         t.eq(map.getResolution(), layer0.resolutions[1],
 706              "correct resolution after removal");
 707     }
 708
 709     function test_Map_removeLayer_zindex(t) {
 710         t.plan(2);
 711
 712         map = new OpenLayers.Map('map');
 713
 714         var layer0 = new OpenLayers.Layer('Test Layer 0', {isBaseLayer:true});
 715         var layer1 = new OpenLayers.Layer('Test Layer 1', {isBaseLayer:true});
 716         var layer2 = new OpenLayers.Layer('Test Layer 2', {isBaseLayer:false});
 717
 718         map.addLayers([layer0, layer1, layer2]);
 719         map.removeLayer(layer0);
 720
 721         t.eq(parseInt(layer1.div.style.zIndex), map.Z_INDEX_BASE['BaseLayer'],
 722              "correct z-index after removeLayer");
 723         t.eq(parseInt(layer2.div.style.zIndex), map.Z_INDEX_BASE['Overlay'] + 5,
 724              "correct z-index after removeLayer");
 725     }
 726
 727     function test_Map_setBaseLayer_after_pan (t) {
 728         t.plan(1);
 729
 730         map = new OpenLayers.Map('map');
 731         var wmsLayer = new OpenLayers.Layer.WMS( "OpenLayers WMS",
 732             "http://labs.metacarta.com/wms/vmap0", {layers: 'basic'} );
 733         var tmsLayer = new OpenLayers.Layer.TMS("TMS",
 734                                     "http://labs.metacarta.com/wms-c/Basic.py/",
 735                                     {'layername':'basic', 'type':'png'});
 736         map.addLayers([wmsLayer,tmsLayer]);
 737         map.setBaseLayer(wmsLayer);
 738         map.zoomToMaxExtent();
 739         map.setBaseLayer(tmsLayer);
 740         map.zoomIn();
 741         map.pan(0, -200, {animate:false});
 742         map.setBaseLayer(wmsLayer);
 743         t.eq(map.layerContainerDiv.style.top, "0px", "layerContainer is recentered after setBaseLayer");
 744     }
 745
 746     function test_Map_moveLayer (t) {
 747         t.plan(10);
 748
 749         var ct  = 0;
 750         map = new OpenLayers.Map('map');
 751         var wmslayer = new OpenLayers.Layer.WMS('Test Layer',
 752                     "http://octo.metacarta.com/cgi-bin/mapserv",
 753                     {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'},
 754                     {maxExtent: new OpenLayers.Bounds(33861, 717605, 330846, 1019656), maxResolution: 296985/1024, projection:"EPSG:2805" } );
 755
 756         var wmslayer2 = new OpenLayers.Layer.WMS('Test Layer2',
 757                     "http://octo.metacarta.com/cgi-bin/mapserv",
 758                     {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'},
 759                     {maxExtent: new OpenLayers.Bounds(33861, 717605, 330846, 1019656), maxResolution: 296985/1024, projection:"EPSG:2805" } );
 760
 761         var wmslayer3 = new OpenLayers.Layer.WMS('Test Layer2',
 762                     "http://octo.metacarta.com/cgi-bin/mapserv",
 763                     {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'},
 764                     {maxExtent: new OpenLayers.Bounds(33861, 717605, 330846, 1019656), maxResolution: 296985/1024, projection:"EPSG:2805" } );
 765
 766         map.addLayers([wmslayer, wmslayer2, wmslayer3]);
 767         map.events.register("changelayer", map, function (e) { ct++; });
 768         t.eq( map.getNumLayers(), 3, "getNumLayers returns the number of layers" );
 769         t.eq( map.getLayerIndex(wmslayer3), 2, "getLayerIndex returns the right index" );
 770         map.raiseLayer(wmslayer3, 1);
 771         t.eq( map.getLayerIndex(wmslayer3), 2, "can't moveLayer up past the top of the stack" );
 772         map.raiseLayer(wmslayer, -1);
 773         t.eq( map.getLayerIndex(wmslayer), 0, "can't moveLayer down past the bottom of the stack" );
 774         map.raiseLayer(wmslayer3, -1);
 775         t.eq( map.getLayerIndex(wmslayer3), 1, "can moveLayer down from the top" );
 776         t.eq( parseInt(wmslayer3.div.style.zIndex), map.Z_INDEX_BASE['BaseLayer'] + 5,
 777             "layer div has the right zIndex after moving down" );
 778         map.raiseLayer(wmslayer, 2);
 779         t.eq( map.getLayerIndex(wmslayer), 2, "can moveLayer up from the bottom" );
 780         t.eq( parseInt(wmslayer.div.style.zIndex), map.Z_INDEX_BASE['BaseLayer'] + 2 * 5,
 781             "layer div has the right zIndex after moving up" );
 782         t.eq( map.getLayerIndex(wmslayer3), 0, "top layer is now on the bottom" );
 783         t.eq( ct, 3, "raiseLayer triggered changelayer the right # of times" );
 784     }
 785
 786     function test_Map_moveTo(t) {
 787         t.plan(2);
 788
 789         map = new OpenLayers.Map('map');
 790         var baseLayer = new OpenLayers.Layer.WMS("Test Layer",
 791             "http://octo.metacarta.com/cgi-bin/mapserv?",
 792             {map: "/mapdata/vmap_wms.map", layers: "basic"},
 793             {maxResolution: 'auto', maxExtent: new OpenLayers.Bounds(-10,-10,10,10)});
 794         baseLayer.events.on({
 795             move: function() {
 796                 t.ok(true, "move listener called");
 797             },
 798             moveend: function(e) {
 799                 t.eq(e.zoomChanged, true, "moveend listener called with expected value");
 800             }
 801         });
 802         map.addLayer(baseLayer);
 803         var ll = new OpenLayers.LonLat(-100,-150);
 804         map.moveTo(ll, 2);
 805         t.ok(map.getCenter().equals(new OpenLayers.LonLat(0,0)), "safely sets out-of-bounds lonlat");
 806     }
 807
 808     function test_Map_defaultTheme(t) {
 809         t.plan(5);
 810
 811         var links = document.getElementsByTagName('link');
 812         map = new OpenLayers.Map('map');
 813         var gotNodes = 0;
 814         var themeNode = null;
 815         for(var i=0; i<links.length; ++i) {
 816             if(OpenLayers.Util.isEquivalentUrl(map.theme, links.item(i).href)) {
 817                 gotNodes += 1;
 818                 themeNode = links.item(i);
 819             }
 820         }
 821         t.eq(gotNodes, 1, "by default, a single link node is added to document");
 822         t.ok(themeNode != null, "a link node with the theme href was added");
 823         t.eq(themeNode.rel, "stylesheet", "node added has rel set to stylesheet");
 824         t.eq(themeNode.type, "text/css", "node added has type set to text/css");
 825
 826         // reconstruct the map to prove that another link is not added
 827         map = new OpenLayers.Map('map');
 828         t.eq(links.length, document.getElementsByTagName('link').length,
 829              "calling the map constructor twice with the same theme doesn't add duplicate link nodes");
 830     }
 831
 832     function test_Map_customTheme(t) {
 833         t.plan(5);
 834
 835         var customTheme = 'foo';
 836         var options = {theme: customTheme};
 837         map = new OpenLayers.Map('map', options);
 838
 839         var links = document.getElementsByTagName('link');
 840         var gotNodes = 0;
 841         var themeNode = null;
 842         for(var i=0; i<links.length; ++i) {
 843             if(OpenLayers.Util.isEquivalentUrl(map.theme, links.item(i).href)) {
 844                 gotNodes += 1;
 845                 themeNode = links.item(i);
 846             }
 847         }
 848
 849         t.eq(map.theme, customTheme, "map theme is properly set");
 850         t.eq(gotNodes, 1, "with custom theme, a single link node is added to document");
 851         t.ok(themeNode != null, "a link node with the theme href was added");
 852         t.eq(themeNode.rel, "stylesheet", "node added has rel set to stylesheet");
 853         t.eq(themeNode.type, "text/css", "node added has type set to text/css");
 854     }
 855
 856     function test_Map_noTheme(t) {
 857         t.plan(1);
 858
 859         var head = document.getElementsByTagName('head')[0];
 860         var nodeCount = head.childNodes.length;
 861
 862         var options = {theme: null};
 863         map = new OpenLayers.Map('map', options);
 864
 865         t.eq(nodeCount, head.childNodes.length, "with no theme, a node is not added to document head" );
 866     }
 867
 868     function test_Map_getControl(t) {
 869         t.plan(2);
 870
 871         var map1 = new OpenLayers.Map('map');
 872
 873         var control = new OpenLayers.Control();
 874         map1.addControl(control);
 875
 876         var gotControl = map1.getControl(control.id);
 877         t.ok(gotControl == control, "got right control");
 878
 879         gotControl = map1.getControl("bogus id");
 880         t.ok(gotControl == null, "getControl() for bad id returns null");
 881     }
 882
 883     function test_Map_removeControl(t) {
 884         t.plan(6);
 885
 886         var oldNumControls, newNumControls;
 887
 888         var map1 = new OpenLayers.Map('map');
 889         oldNumControls = map1.controls.length;
 890
 891         var control = new OpenLayers.Control();
 892         map1.addControl(control);
 893
 894     //add control
 895         newNumControls = map1.controls.length;
 896         t.ok( newNumControls = oldNumControls + 1, "adding a control increases control count")
 897
 898         var foundDiv = false;
 899         for(var i=0; i < map1.viewPortDiv.childNodes.length; i++) {
 900             var childNode = map1.viewPortDiv.childNodes[i];
 901             if (childNode == control.div) {
 902                 foundDiv = true;
 903             }
 904         }
 905         t.ok(foundDiv, "new control's div correctly added to viewPort");
 906
 907     //remove control
 908         map1.removeControl(control)
 909         newNumControls = map1.controls.length;
 910         t.ok( newNumControls == oldNumControls, "removing the control decreases control count")
 911
 912         var gotControl = map1.getControl(control.id);
 913         t.ok( gotControl == null, "control no longer in map's controls array");
 914
 915         var foundDiv = false;
 916         for(var i=0; i < map1.viewPortDiv.childNodes.length; i++) {
 917             var childNode = map1.viewPortDiv.childNodes[i];
 918             if (childNode == control.div) {
 919                 foundDiv = true;
 920             }
 921         }
 922         t.ok(!foundDiv, "control no longer child of viewPort");
 923
 924     //remove bogus
 925         control = { id: "bogus id" };
 926         map1.removeControl(control);
 927         newNumControls = map1.controls.length;
 928         t.ok( newNumControls == oldNumControls, "removing bad controlid doesnt crash or decrease control count")
 929     }
 930
 931     function test_Map_restrictedExtent(t) {
 932         t.plan(24);
 933         var extent = new OpenLayers.Bounds(-180, -90, 180, 90);
 934         var options = {
 935             maxResolution: "auto"
 936         };
 937         var map = new OpenLayers.Map("map", options);
 938         var layer = new OpenLayers.Layer.WMS(
 939             "test",
 940             "http://octo.metacarta.com/cgi-bin/mapserv?",
 941             {map: "/mapdata/vmap_wms.map", layers: "basic"}
 942         );
 943         map.addLayer(layer);
 944         map.zoomToMaxExtent();
 945         var nw = new OpenLayers.LonLat(extent.left, extent.top);
 946         var ne = new OpenLayers.LonLat(extent.right, extent.top);
 947         var sw = new OpenLayers.LonLat(extent.left, extent.bottom);
 948         var se = new OpenLayers.LonLat(extent.right, extent.bottom);
 949
 950         // try panning to northwest corner
 951         map.setOptions({restrictedExtent: extent});
 952         map.setCenter(nw, 0);
 953         t.eq(map.getExtent().getCenterLonLat().toString(),
 954              extent.getCenterLonLat().toString(),
 955              "map extent properly restricted to northwest at zoom 0");
 956         t.eq(map.zoom, 0, "zoom not restricted for nw, 0");
 957         map.setCenter(nw, 5);
 958         t.eq(map.getExtent().top, extent.top,
 959              "map extent top properly restricted to northwest at zoom 5");
 960         t.eq(map.getExtent().left, extent.left,
 961              "map extent left properly restricted to northwest at zoom 5");
 962         t.eq(map.zoom, 5, "zoom not restricted for nw, 5");
 963         map.setOptions({restrictedExtent: null});
 964         map.setCenter(nw, 0);
 965         t.eq(map.getExtent().getCenterLonLat().toString(),
 966              nw.toString(),
 967              "map extent not restricted with null restrictedExtent for nw");
 968
 969         // try panning to northeast corner
 970         map.setOptions({restrictedExtent: extent});
 971         map.setCenter(ne, 0);
 972         t.eq(map.getExtent().getCenterLonLat().toString(),
 973              extent.getCenterLonLat().toString(),
 974              "map extent properly restricted to northeast at zoom 0");
 975         t.eq(map.zoom, 0, "zoom not restricted for ne, 0");
 976         map.setCenter(ne, 5);
 977         t.eq(map.getExtent().top, extent.top,
 978              "map extent top properly restricted to northeast at zoom 5");
 979         t.eq(map.getExtent().right, extent.right,
 980              "map extent right properly restricted to northeast at zoom 5");
 981         t.eq(map.zoom, 5, "zoom not restricted for ne, 5");
 982         map.setOptions({restrictedExtent: null});
 983         map.setCenter(ne, 0);
 984         t.eq(map.getExtent().getCenterLonLat().toString(),
 985              ne.toString(),
 986              "map extent not restricted with null restrictedExtent for ne");
 987
 988         // try panning to southwest corner
 989         map.setOptions({restrictedExtent: extent});
 990         map.setCenter(sw, 0);
 991         t.eq(map.getExtent().getCenterLonLat().toString(),
 992              extent.getCenterLonLat().toString(),
 993              "map extent properly restricted to southwest at zoom 0");
 994         t.eq(map.zoom, 0, "zoom not restricted for sw, 0");
 995         map.setCenter(sw, 5);
 996         t.eq(map.getExtent().bottom, extent.bottom,
 997              "map extent bottom properly restricted to southwest at zoom 5");
 998         t.eq(map.getExtent().left, extent.left,
 999              "map extent left properly restricted to southwest at zoom 5");
1000         t.eq(map.zoom, 5, "zoom not restricted for sw, 5");
1001         map.setOptions({restrictedExtent: null});
1002         map.setCenter(sw, 0);
1003         t.eq(map.getExtent().getCenterLonLat().toString(),
1004              sw.toString(),
1005              "map extent not restricted with null restrictedExtent for sw");
1006
1007         // try panning to southeast corner
1008         map.setOptions({restrictedExtent: extent});
1009         map.setCenter(se, 0);
1010         t.eq(map.getExtent().getCenterLonLat().toString(),
1011              extent.getCenterLonLat().toString(),
1012              "map extent properly restricted to southeast at zoom 0");
1013         t.eq(map.zoom, 0, "zoom not restricted for se, 0");
1014         map.setCenter(se, 5);
1015         t.eq(map.getExtent().bottom, extent.bottom,
1016              "map extent bottom properly restricted to southeast at zoom 5");
1017         t.eq(map.getExtent().right, extent.right,
1018              "map extent right properly restricted to southeast at zoom 5");
1019         t.eq(map.zoom, 5, "zoom not restricted for se, 5");
1020         map.setOptions({restrictedExtent: null});
1021         map.setCenter(se, 0);
1022         t.eq(map.getExtent().getCenterLonLat().toString(),
1023              se.toString(),
1024              "map extent not restricted with null restrictedExtent for se");
1025     }
1026
1027     function test_Map_getResolutionForZoom(t) {
1028         t.plan(2);
1029         var map = new OpenLayers.Map("map");
1030         var res = map.getResolutionForZoom();
1031         t.eq(res, null, "getResolutionForZoom returns null for no base layer");
1032         map.fractionalZoom = true;
1033         var layer = new OpenLayers.Layer("test", {isBaseLayer: true});
1034         layer.getResolutionForZoom = function() {
1035             t.ok(true, "getResolutionForZoom calls base layer getResolutionForZoom");
1036         }
1037         map.addLayer(layer);
1038         var res = map.getResolutionForZoom();
1039         layer.destroy();
1040         map.destroy();
1041     }
1042
1043     function test_Map_getUnits(t) {
1044         t.plan(2);
1045         var map = new OpenLayers.Map("map");
1046         var units = map.getUnits();
1047         t.eq(units, null, "getUnits returns null for no base layer");
1048
1049         var layer = new OpenLayers.Layer("test", {
1050             isBaseLayer: true,
1051             units: 'foo'
1052         });
1053         map.addLayer(layer);
1054         var units = map.getUnits();
1055         t.eq(units, 'foo', "getUnits returns the base layer units property");
1056         layer.destroy();
1057         map.destroy();
1058     }
1059
1060     function test_Map_destroy (t) {
1061         t.plan( 3 );
1062         map = new OpenLayers.Map('map');
1063         map.destroy();
1064         t.eq( map.layers, null, "map.layers is null after destroy" );
1065         t.eq( map.controls, null, "map.controls is null after destroy" );
1066         t.eq( map.viewPortDiv, null, "map's viewportDiv nullified");
1067     }
1068
1069     function test_Map_getMaxExtent(t){
1070         t.plan(5);
1071
1072         var options = null;
1073         var map = {};
1074
1075       //null options, no baseLayer
1076         var maxExtent = OpenLayers.Map.prototype.getMaxExtent.apply(map, [options]);
1077         t.eq(maxExtent, null, "null options, no baseLayer returns null");
1078
1079       //null options.restricted, no baseLayer
1080         maxExtent = OpenLayers.Map.prototype.getMaxExtent.apply(map, [options]);
1081         t.eq(maxExtent, null, "null options.restricted, no baseLayer returns null");
1082
1083       //true options.restricted, null map.restrictedExtent no baseLayer
1084         maxExtent = OpenLayers.Map.prototype.getMaxExtent.apply(map, [options]);
1085         t.eq(maxExtent, null, "true options.restricted, null map.restrictedExtent no baseLayer returns null");
1086
1087       //true options.restricted, valid map.restrictedExtent no baseLayer
1088         options = {
1089             'restricted': true
1090         };
1091         map.restrictedExtent = {};
1092         maxExtent = OpenLayers.Map.prototype.getMaxExtent.apply(map, [options]);
1093         t.ok(maxExtent == map.restrictedExtent, "true options.restricted, valid map.restrictedExtent no baseLayer returns map.restrictedExtent");
1094
1095       //null options, valid baseLayer
1096         options = null;
1097         map.baseLayer = {
1098             'maxExtent': {}
1099         };
1100         var maxExtent = OpenLayers.Map.prototype.getMaxExtent.apply(map, [options]);
1101         t.ok(maxExtent == map.baseLayer.maxExtent, "null options, valid baseLayer returns map.baseLayer.maxExtent");
1102     }
1103
1104     function test_Map_zoomToMaxExtent(t){
1105         t.plan(4)
1106
1107         gMaxExtent = {};
1108
1109         var map = {
1110             'getMaxExtent': function(options) {
1111                 gRestricted = options.restricted;
1112                 return gMaxExtent;
1113             },
1114             'zoomToExtent': function(extent) {
1115                 t.ok(extent == gMaxExtent, "zoomToExtent() always called on return from map.getMaxExtent()");
1116             }
1117         };
1118
1119       //options is null
1120         var options = null;
1121         gRestricted = null;
1122         OpenLayers.Map.prototype.zoomToMaxExtent.apply(map, [options]);
1123         t.eq(gRestricted, true, "default 'restricted' passed to map.getMaxExtent() is true");
1124
1125       //valid options
1126         options = {
1127             'restricted': {}
1128         };
1129         gRestricted = null;
1130         OpenLayers.Map.prototype.zoomToMaxExtent.apply(map, [options]);
1131         t.ok(gRestricted == options.restricted, "when valid options argument, 'options.restricted' passed to map.getMaxExtent()");
1132     }
1133
1134     function test_Map_zoomToScale(t) {
1135         t.plan(4);
1136
1137         var m = {
1138             'baseLayer': { 'units': {} },
1139             'getSize': function() { return {'w': 10, 'h': 15}; },
1140             'getCenter': function() { return {'lon': -5, 'lat': -25}; },
1141             'zoomToExtent': function(extent, closest) {
1142                 t.ok(extent.equals(g_ExpectedExtent), "extent correctly calculated for zoomToExtent()");
1143                 t.ok(closest == g_Closest, "closest correctly passed on to zoomToExtent()");
1144             }
1145         }
1146
1147         var temp = OpenLayers.Util.getResolutionFromScale;
1148         OpenLayers.Util.getResolutionFromScale = function(scale, units) {
1149             t.ok(scale == g_Scale, "scale parameter correctly passed to getResolutionFromScale");
1150             t.ok(units == m.baseLayer.units, "map's baselayer's units parameter correctly passed to getResolutionFromScale");
1151             return 1000;
1152         };
1153
1154         g_ExpectedExtent = new OpenLayers.Bounds(-5005,-7525,4995,7475);
1155         g_Scale = {};
1156         g_Closest = {};
1157         var args = [g_Scale, g_Closest];
1158         OpenLayers.Map.prototype.zoomToScale.apply(m, args);
1159
1160         OpenLayers.Util.getResolutionFromScale = temp;
1161     }
1162
1163     function test_Map_zoomToExtent(t) {
1164         t.plan(8);
1165
1166
1167         var m = {
1168             'baseLayer': {
1169                 'wrapDateLine': false
1170             },
1171             'setCenter': function(center, zoomLevel) {
1172                 g_Center = center;
1173                 g_ZoomLevel = zoomLevel;
1174             },
1175             'getZoomForExtent': function(bounds, closest) {
1176                 t.ok(bounds.equals(g_ToCenterBounds), "bounds correctly passed into getZoomForExtent()");
1177                 t.ok(closest == g_Closest, "closest correctly passed along to getZoomForExtent()");
1178                 return g_ZoomLevelReturn;
1179             }
1180         };
1181
1182     //no wrapDateLine
1183         g_ZoomLevelReturn = {};
1184         g_Bounds = new OpenLayers.Bounds(-20,-15,0,5);
1185         g_ExpectedCenter = new OpenLayers.LonLat(-10,-5);
1186         g_Closest = {};
1187         g_ToCenterBounds = g_Bounds;
1188         var args = [g_Bounds, g_Closest];
1189         OpenLayers.Map.prototype.zoomToExtent.apply(m, args);
1190
1191         t.ok(g_Center.equals(g_ExpectedCenter), "setCenter called on correct center");
1192         t.ok(g_ZoomLevel == g_ZoomLevelReturn, "correctly passes along zoom level as returned from getZoomForExtent()");
1193
1194
1195     //wrapDateLine
1196         m.baseLayer.wrapDateLine = true;
1197         m.getMaxExtent = function() { return new OpenLayers.Bounds(-200,-200,200,200); };
1198
1199         g_ZoomLevelReturn = {};
1200         g_BoundsCenter = {};
1201         g_Bounds = new OpenLayers.Bounds(160,-60,-60,60);
1202         g_ExpectedCenter = new OpenLayers.LonLat(-150,0);
1203         g_Closest = {};
1204         g_ToCenterBounds = new OpenLayers.Bounds(160,-60,340,60);
1205         var args = [g_Bounds, g_Closest];
1206         OpenLayers.Map.prototype.zoomToExtent.apply(m, args);
1207         t.ok(g_Center.equals(g_ExpectedCenter), "setCenter called on correct center");
1208         t.ok(g_ZoomLevel == g_ZoomLevelReturn, "correctly passes along zoom level as returned from getZoomForExtent()");
1209
1210
1211     }
1212
1213     function test_allOverlays(t) {
1214
1215         t.plan(16);
1216
1217         var map = new OpenLayers.Map({
1218             div: "map", allOverlays: true
1219         });
1220
1221         var a = new OpenLayers.Layer.Vector("a", {visibility: true});
1222
1223         var b = new OpenLayers.Layer.Image(
1224             "b",
1225             "http://earthtrends.wri.org/images/maps/4_m_citylights_lg.gif",
1226             new OpenLayers.Bounds(-180, -88.759, 180, 88.759),
1227             new OpenLayers.Size(580, 288)
1228         );
1229
1230         var c = new OpenLayers.Layer.WMS(
1231             "c",
1232             "http://labs.metacarta.com/wms/vmap0",
1233             {layers: 'basic'}
1234         );
1235
1236         var d = new OpenLayers.Layer.Vector("d");
1237
1238         map.addLayers([a, b, c, d]);
1239
1240         var moveCount = 0;
1241         a.moveTo = function() {
1242             moveCount++;
1243             OpenLayers.Layer.Vector.prototype.moveTo.apply(this, arguments);
1244         };
1245
1246         map.zoomToMaxExtent();
1247         t.eq(moveCount, 1, "map.moveTo moves the base layer only once");
1248         t.eq(map.getCenter().toString(), "lon=0,lat=0", "a map with all overlays can have a center");
1249
1250         a.setVisibility(false);
1251         var moveend = 0;
1252         a.events.on({"moveend": function() { moveend++; }});
1253         map.zoomToMaxExtent();
1254         t.eq(moveCount, 1, "map.moveTo does not move the base layer if it is invisible");
1255         t.eq(moveend, 0, "map.moveTo does not trigger \"moveend\" in the layer if the layer is invisible");
1256         a.setVisibility(true);
1257
1258         // a, b, c, d
1259         t.eq(map.baseLayer.name, "a", "base layer set to first layer added");
1260
1261         map.removeLayer(a);
1262         // b, c, d
1263         t.eq(map.baseLayer.name, "b", "if base layer is removed, lowest layer becomes base");
1264
1265         map.addLayer(a);
1266         // b, c, d, a
1267         t.eq(map.baseLayer.name, "b", "adding a new layer doesn't change base layer");
1268
1269         map.setLayerIndex(c, 1);
1270         // b, d, c, a
1271         t.eq(map.baseLayer.name, "b", "changing layer order above base doesn't mess with base");
1272
1273         map.setLayerIndex(d, 0);
1274         // d, b, c, a
1275         t.eq(map.baseLayer.name, "d", "changing layer order to 0 sets base layer");
1276
1277         map.raiseLayer(d, 1);
1278         // b, d, c, a
1279         t.eq(map.baseLayer.name, "b", "raising the base layer sets a new base layer");
1280
1281         map.raiseLayer(d, -1);
1282         // d, b, c, a
1283         t.eq(map.baseLayer.name, "d", "lowering a layer to lowest index sets as base");
1284
1285         // all this switching of base layer didn't muck with layer visibility
1286         t.eq(a.visibility, true, "a is visible");
1287         t.eq(b.visibility, true, "b is visible");
1288         t.eq(c.visibility, true, "c is visible");
1289         t.eq(d.visibility, true, "d is visible");
1290
1291         // test that map can have an invisible base layer
1292         b.setVisibility(false);
1293         map.setLayerIndex(b, 0);
1294         t.eq(b.visibility, false, "changing layer order doesn't change visibility");
1295
1296
1297         map.destroy();
1298
1299     }
1300
1301   </script>
1302 </head>
1303 <body>
1304     <div id="map" style="width: 600px; height: 300px;"/>
1305 </body>
1306 </html>