File: Map.html

package info (click to toggle)
openlayers 2.13.1%2Bds2-4
links: PTS, VCS
area: main
in suites: stretch
size: 67,180 kB
ctags: 11,977
sloc: xml: 7,435; python: 891; sh: 44; makefile: 23
file content (2255 lines) | stat: -rw-r--r-- 86,780 bytes
parent folder | download | duplicates (6)
<html>
<head>
    <script>
    /**
    * Because browsers that implement requestAnimationFrame may not execute
    * animation functions while a window is not displayed (e.g. in a hidden
    * iframe as in these tests), we mask the native implementations here.  The
    * native requestAnimationFrame functionality is tested in Util.html and
    * in PanZoom.html (where a popup is opened before panning).  The panTo tests
    * here will test the fallback setTimeout implementation for animation.
    */
    window.requestAnimationFrame = 
        window.webkitRequestAnimationFrame =
        window.mozRequestAnimationFrame =
        window.oRequestAnimationFrame =
        window.msRequestAnimationFrame = null;
    </script>
    <script src="OLLoader.js"></script>
    <script type="text/javascript">

    var isMozilla = (navigator.userAgent.indexOf("compatible") == -1);
    var map;

    function test_Map_constructor (t) {
        t.plan( 11 );
        
        map = new OpenLayers.Map('map'); 
        var baseLayer = new OpenLayers.Layer.WMS("Test Layer", 
            "http://octo.metacarta.com/cgi-bin/mapserv?",
            {map: "/mapdata/vmap_wms.map", layers: "basic"});
        map.addLayer(baseLayer);

        t.ok( OpenLayers.Element.hasClass(map.div, "olMap"), "Map div has olMap class");

        t.ok( map instanceof OpenLayers.Map, "new OpenLayers.Map returns object" );
        if (!isMozilla) {
            t.ok( true, "skipping element test outside of Mozilla");
            t.ok( true, "skipping element test outside of Mozilla");
            t.ok( true, "skipping element test outside of Mozilla");
        } else {
            t.ok( map.div instanceof HTMLDivElement, "map.div is an HTMLDivElement" );
            t.ok( map.viewPortDiv instanceof HTMLDivElement, "map.viewPortDiv is an HTMLDivElement" );
            t.ok( map.layerContainerDiv instanceof HTMLDivElement, "map.layerContainerDiv is an HTMLDivElement" );
        }
        t.ok( map.layers instanceof Array, "map.layers is an Array" );
        t.ok( map.controls instanceof Array, "map.controls is an Array" );
        t.eq( map.controls.length, 4, "Default map has 4 controls." );
        t.ok( map.events instanceof OpenLayers.Events, "map.events is an OpenLayers.Events" );
        t.ok( map.getMaxExtent() instanceof OpenLayers.Bounds, "map.maxExtent is an OpenLayers.Bounds" );
        t.ok( map.getNumZoomLevels() > 0, "map has a default numZoomLevels" );

        map.destroy();
    }
    
    function test_Map_constructor_convenience(t) {
        t.plan(13);
        var map = new OpenLayers.Map({
            maxExtent: [-170, -80, 170, 80],
            restrictedExtent: [-120, -65, 120, 65],
            layers: [
                new OpenLayers.Layer(null, {isBaseLayer: true})
            ],
            center: [-111, 45],
            zoom: 3
        });
        
        // maxExtent from array
        t.ok(map.maxExtent instanceof OpenLayers.Bounds, "maxExtent bounds");
        t.eq(map.maxExtent.left, -170, "maxExtent left");
        t.eq(map.maxExtent.bottom, -80, "maxExtent bottom");
        t.eq(map.maxExtent.right, 170, "maxExtent right");
        t.eq(map.maxExtent.top, 80, "maxExtent top");

        // restrictedExtent from array
        t.ok(map.restrictedExtent instanceof OpenLayers.Bounds, "restrictedExtent bounds");
        t.eq(map.restrictedExtent.left, -120, "restrictedExtent left");
        t.eq(map.restrictedExtent.bottom, -65, "restrictedExtent bottom");
        t.eq(map.restrictedExtent.right, 120, "restrictedExtent right");
        t.eq(map.restrictedExtent.top, 65, "restrictedExtent top");
        
        var center = map.getCenter();
        t.eq(center.lon, -111, "center lon");
        t.eq(center.lat, 45, "center lat");
        
        t.eq(map.getZoom(), 3, "zoom");
        
        map.destroy();
    }
    
    function test_Map_constructor_late_rendering(t) {
        t.plan( 4 );
        
        map = new OpenLayers.Map(); 
        var baseLayer = new OpenLayers.Layer.WMS("Test Layer", 
            "http://octo.metacarta.com/cgi-bin/mapserv?",
            {map: "/mapdata/vmap_wms.map", layers: "basic"});
        map.addLayer(baseLayer);
        
        t.ok(map.div != null, "Map has a div even though none was specified.");
        t.ok(map.viewPortDiv.parentNode == map.div, "Map is attached to a temporary div that holds the viewPortDiv.");
        
        var mapDiv = document.getElementById("map");
        // clean up the effects of other tests
        while(OpenLayers.Element.hasClass(mapDiv, "olMap")) {
            OpenLayers.Element.removeClass(mapDiv, "olMap");
        }
        map.render(mapDiv); // Can also take a string.
        
        t.ok(map.div == mapDiv, "Map is now rendered to the 'map' div.")
        t.ok( OpenLayers.Element.hasClass(map.div, "olMap"), "Map div has olMap class");
        
        map.destroy();
        
    }
    
    function test_Map_constructor_renderTo(t) {
        t.plan( 1 );
        
        map = new OpenLayers.Map({
            div: "map"
        }); 
        var baseLayer = new OpenLayers.Layer.WMS("Test Layer", 
            "http://octo.metacarta.com/cgi-bin/mapserv?",
            {map: "/mapdata/vmap_wms.map", layers: "basic"});
        map.addLayer(baseLayer);
        
        var mapDiv = document.getElementById("map");
        t.ok(map.div == mapDiv, "Map is rendered to the 'map' div.")
        
        map.destroy();
    }

    function test_Map_setOptions(t) {
        t.plan(2);
        map = new OpenLayers.Map('map', {maxExtent: new OpenLayers.Bounds(100, 200, 300, 400)});
        map.setOptions({theme: 'foo'});
        
        t.eq(map.theme, 'foo', "theme is correctly set by setOptions");
        t.ok(map.maxExtent.equals(new OpenLayers.Bounds(100, 200, 300, 400)), 
             "maxExtent is correct after calling setOptions");
        
        map.destroy();
    }

    function test_Map_add_layers(t) {
        t.plan(8);
        map = new OpenLayers.Map('map');
        var layer1 = new OpenLayers.Layer.WMS("Layer 1", 
            "http://octo.metacarta.com/cgi-bin/mapserv?",
            {map: "/mapdata/vmap_wms.map", layers: "basic"});
        var layer2 = new OpenLayers.Layer.WMS("Layer 2",
            "http://wms.jpl.nasa.gov/wms.cgi", {layers: "modis,global_mosaic"});
        // this uses map.addLayer internally
        map.addLayers([layer1, layer2])
        t.eq( map.layers.length, 2, "map has exactly two layers" );
        t.ok( map.layers[0] === layer1, "1st layer is layer1" );
        t.ok( map.layers[1] === layer2, "2nd layer is layer2" );
        t.ok( layer1.map === map, "layer.map is map" ); 
        t.eq( parseInt(layer1.div.style.zIndex), map.Z_INDEX_BASE['BaseLayer'], 
                "layer1 zIndex is set" );
        t.eq( parseInt(layer2.div.style.zIndex), map.Z_INDEX_BASE['BaseLayer'] + 5, 
                "layer2 zIndex is set" );

        map.events.register('preaddlayer', this, function(evt) {
            return !(evt.layer.name === 'donotadd');
        });
        var layer3 = new OpenLayers.Layer.WMS("donotadd",
            "http://octo.metacarta.com/cgi-bin/mapserv?",
            {map: "/mapdata/vmap_wms.map", layers: "basic"});
        map.addLayers([layer3]);
        t.eq(map.layers.length, 2, "layer is not added since preaddlayer returns false");
        layer3.name = 'pleaseadd';
        map.addLayers([layer3]);
        t.eq(map.layers.length, 3, "layer is added since preaddlayer returns true");
        
        map.destroy();
    }

    function test_Map_options(t) {
        t.plan(3);
        map = new OpenLayers.Map('map', {numZoomLevels: 6, maxResolution: 3.14159, theme: 'foo'});
        t.eq( map.numZoomLevels, 6, "map.numZoomLevels set correctly via options hashtable" );
        t.eq( map.maxResolution, 3.14159, "map.maxResolution set correctly via options hashtable" );
        t.eq( map.theme, 'foo', "map theme set correctly." );

        map.destroy();
    }
    
    function test_eventListeners(t) {
        t.plan(1);
        
        var method = OpenLayers.Events.prototype.on;
        // test that events.on is called at map construction
        var options = {
            eventListeners: {foo: "bar"},
            tileManager: null,
            controls: []
        };
        OpenLayers.Events.prototype.on = function(obj) {
            t.eq(obj, options.eventListeners, "events.on called with eventListeners");
        }
        var map = new OpenLayers.Map('map', options);
        OpenLayers.Events.prototype.on = method;
        map.destroy();

        // if events.on is called again, this will fail due to an extra test
        // test map without eventListeners
        OpenLayers.Events.prototype.on = function(obj) {
            t.fail("events.on called without eventListeners");
        }
        var map2 = new OpenLayers.Map("map", {tileManager: null, controls: []});
        OpenLayers.Events.prototype.on = method;
        map2.destroy();
    }

    function test_Map_center(t) {
        t.plan(14);
        var log = [];
        map = new OpenLayers.Map('map', {
            zoomMethod: null,
            eventListeners: {
                "movestart": function() {log.push("movestart");},
                "move": function() {log.push("move");},
                "moveend": function() {log.push("moveend");}
            }            
        });
        var baseLayer = new OpenLayers.Layer.WMS("Test Layer", 
            "http://octo.metacarta.com/cgi-bin/mapserv?",
            {map: "/mapdata/vmap_wms.map", layers: "basic"} );
        map.addLayer(baseLayer);
        var ll = new OpenLayers.LonLat(2,1);
        map.setCenter(ll, 0);
        t.ok( map.getCenter() instanceof OpenLayers.LonLat, "map.getCenter returns a LonLat");
        t.eq( map.getZoom(), 0, "map.zoom is correct after calling setCenter");
        t.ok( map.getCenter().equals(ll), "map center is correct after calling setCenter");
        map.zoomIn();
        t.eq( map.getZoom(), 1, "map.zoom is correct after calling setCenter,zoom in");
        t.ok( map.getCenter().equals(ll), "map center is correct after calling setCenter, zoom in");
        map.zoomOut();
        t.eq( map.getZoom(), 0, "map.zoom is correct after calling setCenter,zoom in, zoom out");
        
        log = [];
        map.zoomTo(5);
        t.eq(log[0], "movestart", "zoomTo fires movestart event");
        t.eq(log[1], "move", "zoomTo fires move event");
        t.eq(log[2], "moveend", "zoomTo fires moveend event");
        t.eq( map.getZoom(), 5, "map.zoom is correct after calling zoomTo" );

    /**
        map.zoomToMaxExtent();
        t.eq( map.getZoom(), 2, "map.zoom is correct after calling zoomToMaxExtent" );
        var lonlat = map.getCenter();
        var zero = new OpenLayers.LonLat(0, 0);
        t.ok( lonlat.equals(zero), "map center is correct after calling zoomToFullExtent" );
    */

        map.getCenter().lon = 10;
        t.ok( map.getCenter().equals(ll), "map.getCenter returns a clone of map.center");

        // allow calling setCenter with an array
        map.setCenter([4, 2]);
        var center = map.getCenter();
        t.ok(center instanceof OpenLayers.LonLat, "(array) center is lonlat");
        t.eq(center.lon, 4, "(array) center lon");
        t.eq(center.lat, 2, "(array) center lat");

        map.destroy();
    }

    function test_Map_zoomend_event (t) {
        t.plan(2);

        map = new OpenLayers.Map('map', {zoomMethod: null});
        var baseLayer = new OpenLayers.Layer.WMS("Test Layer", 
            "http://octo.metacarta.com/cgi-bin/mapserv?",
            {map: "/mapdata/vmap_wms.map", layers: "basic"});
        map.addLayer(baseLayer);
        map.events.register("zoomend", {count: 0}, function() { 
            this.count++; 
            t.ok(true, "zoomend event was triggered " + this.count + " times");
            });
        map.setCenter(new OpenLayers.LonLat(2, 1), 0);
        map.zoomIn();
        map.zoomOut();

        map.destroy();
    }

    function test_Map_add_remove_popup (t) {
        t.plan(4);

        map = new OpenLayers.Map('map');
        var baseLayer = new OpenLayers.Layer.WMS("Test Layer", 
            "http://octo.metacarta.com/cgi-bin/mapserv?",
            {map: "/mapdata/vmap_wms.map", layers: "basic"});
        map.addLayer(baseLayer);
        
        var popup = new OpenLayers.Popup("chicken", 
                                         new OpenLayers.LonLat(0,0),
                                         new OpenLayers.Size(200,200));
        map.setCenter(new OpenLayers.LonLat(0, 0), 0);

        map.addPopup(popup);
        var pIndex = OpenLayers.Util.indexOf(map.popups, popup);
        t.eq(pIndex, 0, "popup successfully added to Map's internal popups array");

        var nodes = map.layerContainerDiv.childNodes;
        
        var found = false;
        for (var i=0; i < nodes.length; i++) {
            if (nodes.item(i) == popup.div) {
                found = true;
                break;
            }
        }
        t.ok(found, "popup.div successfully added to the map's viewPort");

        
        map.removePopup(popup);
        var pIndex = OpenLayers.Util.indexOf(map.popups, popup);
        t.eq(pIndex, -1, "popup successfully removed from Map's internal popups array");

        var found = false;
        for (var i=0; i < nodes.length; i++) {
            if (nodes.item(i) == popup.div) {
                found = true;
                break;
            }
        }
        t.ok(!found, "popup.div successfully removed from the map's viewPort");

        map.destroy();
    }

    function test_Map_add_popup_exclusive(t) {
        t.plan(2);

        map = new OpenLayers.Map('map');
        var baseLayer = new OpenLayers.Layer.WMS("Test Layer", 
            "http://octo.metacarta.com/cgi-bin/mapserv?",
            {map: "/mapdata/vmap_wms.map", layers: "basic"});
        map.addLayer(baseLayer);
        
        map.setCenter(new OpenLayers.LonLat(0, 0), 0);

        for (var i = 0; i < 10; i++) {
            var popup = new OpenLayers.Popup("chicken", 
                                             new OpenLayers.LonLat(0,0),
                                             new OpenLayers.Size(200,200));
            map.addPopup(popup);
        }
        t.eq(map.popups.length, 10, "addPopup non exclusive mode works");

        var popup = new OpenLayers.Popup("chicken", 
                                         new OpenLayers.LonLat(0,0),
                                         new OpenLayers.Size(200,200));
        map.addPopup(popup, true);
        t.eq(map.popups.length, 1, "addPopup exclusive mode works");

        map.destroy();
    }   
    

/***  THIS IS A GOOD TEST, BUT IT SHOULD BE MOVED TO WMS. 
 *     Also, it won't work until we figure out the viewSize bug

    function 08_Map_px_lonlat_translation (t) {
        t.plan( 6 );    
        map = new OpenLayers.Map('map');
        var baseLayer = new OpenLayers.Layer.WMS("Test Layer", 
            "http://octo.metacarta.com/cgi-bin/mapserv?",
            {map: "/mapdata/vmap_wms.map", layers: "basic"});
        map.addLayer(baseLayer);
        map.setCenter(new OpenLayers.LonLat(0, 0), 0);
 
        var pixel = new OpenLayers.Pixel(50,150);
        var lonlat = map.getLonLatFromViewPortPx(pixel);
        t.ok( lonlat instanceof OpenLayers.LonLat, "getLonLatFromViewPortPx returns valid OpenLayers.LonLat" );

        var newPixel = map.getViewPortPxFromLonLat(lonlat);
        t.ok( newPixel instanceof OpenLayers.Pixel, "getViewPortPxFromLonLat returns valid OpenLayers.Pixel" );

        // WARNING!!!  I'm faily sure that the following test's validity 
        //             depends highly on rounding and the resolution. For now,
        //             in the default case, it seems to work. This may not 
        //             always be so.
        t.ok( newPixel.equals(pixel), "Translation to pixel and back to lonlat is consistent");

        lonlat = map.getLonLatFromPixel(pixel);
        t.ok( lonlat instanceof OpenLayers.LonLat, "getLonLatFromPixel returns valid OpenLayers.LonLat" );

        newPixel = map.getPixelFromLonLat(lonlat);
        t.ok( newPixel instanceof OpenLayers.Pixel, "getPixelFromLonLat returns valid OpenLayers.Pixel" );

        t.ok( newPixel.equals(pixel), "2nd translation to pixel and back to lonlat is consistent");
    }
 */

    function test_Map_isValidZoomLevel(t) {
        t.plan(5);
        var map = new OpenLayers.Map("map");
        map.addLayer(new OpenLayers.Layer(null, {
            isBaseLayer: true, wrapDateLine: true, numZoomLevels: 19
        }));
        map.zoomToMaxExtent();
        
        var valid;

        valid = OpenLayers.Map.prototype.isValidZoomLevel.apply(map, [-1]);
        t.eq(valid, false, "-1 is not a valid zoomLevel");

        valid = OpenLayers.Map.prototype.isValidZoomLevel.apply(map, [0]);
        t.eq(valid, true, "0 is a valid zoomLevel");

        valid = OpenLayers.Map.prototype.isValidZoomLevel.apply(map, [18]);
        t.eq(valid, true, "18 is a valid zoomLevel");

        valid = OpenLayers.Map.prototype.isValidZoomLevel.apply(map, [19]);
        t.eq(valid, false, "19 is not a valid zoomLevel");
        
        map.moveTo([16, 48], 0);
        t.eq(map.getCenter().toShortString(), "0, 0", "no panning when moveTo is called with invalid zoom");

        map.destroy();
    }
    
    function test_Map_isValidLonLat(t) {
        t.plan( 3 );    

        map = new OpenLayers.Map('map');
        layer = new OpenLayers.Layer.WMS('Test Layer', 
                    "http://octo.metacarta.com/cgi-bin/mapserv", 
                    {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'}, 
                    {maxExtent: new OpenLayers.Bounds(33861, 717605, 330846, 1019656), maxResolution: 296985/1024, projection:"EPSG:2805" } );
        map.addLayer(layer);
        
        t.ok( !map.isValidLonLat(null), "null lonlat is not valid" );
        t.ok( map.isValidLonLat(new OpenLayers.LonLat(33862, 717606)), "lonlat outside max extent is valid" );
        t.ok( !map.isValidLonLat(new OpenLayers.LonLat(10, 10)), "lonlat outside max extent is not valid" );

        map.destroy();
    }

    function test_Map_getLayer(t) {
        var numLayers = 3;
        t.plan( numLayers + 1 );    

        var m = {
            layers: []
        };
        
        for(var i = 0; i < numLayers; i++) {
            m.layers.push( { 'id': i } );
        }

        for(var i = 0; i < numLayers; i++) {
            var layer = OpenLayers.Map.prototype.getLayer.apply(m, [i]);
            t.ok( layer == m.layers[i], "getLayer correctly returns layer " + i);
        }

        var gotLayer = OpenLayers.Map.prototype.getLayer.apply(m, ["chicken"]);
        t.ok( gotLayer == null, "getLayer correctly returns null when layer not found");

        map.destroy();
    }

    function test_Map_getLayersBy(t) {
        
        var map = {
            getBy: OpenLayers.Map.prototype.getBy,
            getLayersBy: OpenLayers.Map.prototype.getLayersBy,
            layers: [
                {foo: "foo", id: Math.random()},
                {foo: "bar", id: Math.random()},
                {foo: "foobar", id: Math.random()},
                {foo: "foo bar", id: Math.random()},
                {foo: "foo", id: Math.random()}
            ]
        };

        var cases = [
            {
                got: map.getLayersBy("foo", "foo"),
                expected: [map.layers[0], map.layers[4]],
                message: "(string literal) got two layers matching foo"
            }, {
                got: map.getLayersBy("foo", "bar"),
                expected: [map.layers[1]],
                message: "(string literal) got one layer matching foo"
            }, {
                got: map.getLayersBy("foo", "barfoo"),
                expected: [],
                message: "(string literal) got empty array for no foo match"
            }, {
                got: map.getLayersBy("foo", /foo/),
                expected: [map.layers[0], map.layers[2], map.layers[3], map.layers[4]],
                message: "(regexp literal) got three layers containing string"
            }, {
                got: map.getLayersBy("foo", /foo$/),
                expected: [map.layers[0], map.layers[4]],
                message: "(regexp literal) got three layers ending with string"
            }, {
                got: map.getLayersBy("foo", /\s/),
                expected: [map.layers[3]],
                message: "(regexp literal) got layer containing space"
            }, {
                got: map.getLayersBy("foo", new RegExp("BAR", "i")),
                expected: [map.layers[1], map.layers[2], map.layers[3]],
                message: "(regexp object) got layers ignoring case"
            }, {
                got: map.getLayersBy("foo", {test: function(str) {return str.length > 3;}}),
                expected: [map.layers[2], map.layers[3]],
                message: "(custom object) got layers with foo length greater than 3"
            }
        ];
        t.plan(cases.length);
        for(var i=0; i<cases.length; ++i) {
            t.eq(cases[i].got, cases[i].expected, cases[i].message);
        }
        
    }

    function test_Map_getLayersByName(t) {
        
        var map = {
            getBy: OpenLayers.Map.prototype.getBy,
            getLayersBy: OpenLayers.Map.prototype.getLayersBy,
            getLayersByName: OpenLayers.Map.prototype.getLayersByName,
            layers: [
                {name: "foo", id: Math.random()},
                {name: "bar", id: Math.random()},
                {name: "foobar", id: Math.random()},
                {name: "foo bar", id: Math.random()},
                {name: "foo", id: Math.random()}
            ]
        };

        var cases = [
            {
                got: map.getLayersByName("foo"),
                expected: [map.layers[0], map.layers[4]],
                message: "(string literal) got two layers matching name"
            }, {
                got: map.getLayersByName("bar"),
                expected: [map.layers[1]],
                message: "(string literal) got one layer matching name"
            }, {
                got: map.getLayersByName("barfoo"),
                expected: [],
                message: "(string literal) got empty array for no match"
            }, {
                got: map.getLayersByName(/foo/),
                expected: [map.layers[0], map.layers[2], map.layers[3], map.layers[4]],
                message: "(regexp literal) got three layers containing string"
            }, {
                got: map.getLayersByName(/foo$/),
                expected: [map.layers[0], map.layers[4]],
                message: "(regexp literal) got three layers ending with string"
            }, {
                got: map.getLayersByName(/\s/),
                expected: [map.layers[3]],
                message: "(regexp literal) got layer containing space"
            }, {
                got: map.getLayersByName(new RegExp("BAR", "i")),
                expected: [map.layers[1], map.layers[2], map.layers[3]],
                message: "(regexp object) got layers ignoring case"
            }, {
                got: map.getLayersByName({test: function(str) {return str.length > 3;}}),
                expected: [map.layers[2], map.layers[3]],
                message: "(custom object) got layers with name length greater than 3"
            }
        ];
        t.plan(cases.length);
        for(var i=0; i<cases.length; ++i) {
            t.eq(cases[i].got, cases[i].expected, cases[i].message);
        }
        
    }

    function test_Map_getLayersByClass(t) {
        
        var map = {
            getBy: OpenLayers.Map.prototype.getBy,
            getLayersBy: OpenLayers.Map.prototype.getLayersBy,
            getLayersByClass: OpenLayers.Map.prototype.getLayersByClass,
            layers: [
                {CLASS_NAME: "foo", id: Math.random()},
                {CLASS_NAME: "bar", id: Math.random()},
                {CLASS_NAME: "foobar", id: Math.random()},
                {CLASS_NAME: "foo bar", id: Math.random()},
                {CLASS_NAME: "foo", id: Math.random()}
            ]
        };

        var cases = [
            {
                got: map.getLayersByClass("foo"),
                expected: [map.layers[0], map.layers[4]],
                message: "(string literal) got two layers matching type"
            }, {
                got: map.getLayersByClass("bar"),
                expected: [map.layers[1]],
                message: "(string literal) got one layer matching type"
            }, {
                got: map.getLayersByClass("barfoo"),
                expected: [],
                message: "(string literal) got empty array for no match"
            }, {
                got: map.getLayersByClass(/foo/),
                expected: [map.layers[0], map.layers[2], map.layers[3], map.layers[4]],
                message: "(regexp literal) got three layers containing string"
            }, {
                got: map.getLayersByClass(/foo$/),
                expected: [map.layers[0], map.layers[4]],
                message: "(regexp literal) got three layers ending with string"
            }, {
                got: map.getLayersByClass(/\s/),
                expected: [map.layers[3]],
                message: "(regexp literal) got layer containing space"
            }, {
                got: map.getLayersByClass(new RegExp("BAR", "i")),
                expected: [map.layers[1], map.layers[2], map.layers[3]],
                message: "(regexp object) got layers ignoring case"
            }, {
                got: map.getLayersByClass({test: function(str) {return str.length > 3;}}),
                expected: [map.layers[2], map.layers[3]],
                message: "(custom object) got layers with type length greater than 3"
            }
        ];
        t.plan(cases.length);
        for(var i=0; i<cases.length; ++i) {
            t.eq(cases[i].got, cases[i].expected, cases[i].message);
        }
        
    }

    function test_Map_getControlsBy(t) {
        
        var map = {
            getBy: OpenLayers.Map.prototype.getBy,
            getControlsBy: OpenLayers.Map.prototype.getControlsBy,
            controls: [
                {foo: "foo", id: Math.random()},
                {foo: "bar", id: Math.random()},
                {foo: "foobar", id: Math.random()},
                {foo: "foo bar", id: Math.random()},
                {foo: "foo", id: Math.random()}
            ]
        };

        var cases = [
            {
                got: map.getControlsBy("foo", "foo"),
                expected: [map.controls[0], map.controls[4]],
                message: "(string literal) got two controls matching foo"
            }, {
                got: map.getControlsBy("foo", "bar"),
                expected: [map.controls[1]],
                message: "(string literal) got one control matching foo"
            }, {
                got: map.getControlsBy("foo", "barfoo"),
                expected: [],
                message: "(string literal) got empty array for no foo match"
            }, {
                got: map.getControlsBy("foo", /foo/),
                expected: [map.controls[0], map.controls[2], map.controls[3], map.controls[4]],
                message: "(regexp literal) got three controls containing string"
            }, {
                got: map.getControlsBy("foo", /foo$/),
                expected: [map.controls[0], map.controls[4]],
                message: "(regexp literal) got three controls ending with string"
            }, {
                got: map.getControlsBy("foo", /\s/),
                expected: [map.controls[3]],
                message: "(regexp literal) got control containing space"
            }, {
                got: map.getControlsBy("foo", new RegExp("BAR", "i")),
                expected: [map.controls[1], map.controls[2], map.controls[3]],
                message: "(regexp object) got layers ignoring case"
            }, {
                got: map.getControlsBy("foo", {test: function(str) {return str.length > 3;}}),
                expected: [map.controls[2], map.controls[3]],
                message: "(custom object) got controls with foo length greater than 3"
            }
        ];
        t.plan(cases.length);
        for(var i=0; i<cases.length; ++i) {
            t.eq(cases[i].got, cases[i].expected, cases[i].message);
        }
        
    }

    function test_Map_getControlsByClass(t) {
        
        var map = {
            getBy: OpenLayers.Map.prototype.getBy,
            getControlsBy: OpenLayers.Map.prototype.getControlsBy,
            getControlsByClass: OpenLayers.Map.prototype.getControlsByClass,
            controls: [
                {CLASS_NAME: "foo", id: Math.random()},
                {CLASS_NAME: "bar", id: Math.random()},
                {CLASS_NAME: "foobar", id: Math.random()},
                {CLASS_NAME: "foo bar", id: Math.random()},
                {CLASS_NAME: "foo", id: Math.random()}
            ]
        };

        var cases = [
            {
                got: map.getControlsByClass("foo"),
                expected: [map.controls[0], map.controls[4]],
                message: "(string literal) got two controls matching type"
            }, {
                got: map.getControlsByClass("bar"),
                expected: [map.controls[1]],
                message: "(string literal) got one control matching type"
            }, {
                got: map.getControlsByClass("barfoo"),
                expected: [],
                message: "(string literal) got empty array for no match"
            }, {
                got: map.getControlsByClass(/foo/),
                expected: [map.controls[0], map.controls[2], map.controls[3], map.controls[4]],
                message: "(regexp literal) got three controls containing string"
            }, {
                got: map.getControlsByClass(/foo$/),
                expected: [map.controls[0], map.controls[4]],
                message: "(regexp literal) got three controls ending with string"
            }, {
                got: map.getControlsByClass(/\s/),
                expected: [map.controls[3]],
                message: "(regexp literal) got control containing space"
            }, {
                got: map.getControlsByClass(new RegExp("BAR", "i")),
                expected: [map.controls[1], map.controls[2], map.controls[3]],
                message: "(regexp object) got controls ignoring case"
            }, {
                got: map.getControlsByClass({test: function(str) {return str.length > 3;}}),
                expected: [map.controls[2], map.controls[3]],
                message: "(custom object) got controls with type length greater than 3"
            }
        ];
        t.plan(cases.length);
        for(var i=0; i<cases.length; ++i) {
            t.eq(cases[i].got, cases[i].expected, cases[i].message);
        }
        
    }

    function test_Map_double_addLayer(t) {
        t.plan(2);

        map = new OpenLayers.Map('map');
        layer = new OpenLayers.Layer.WMS('Test Layer', 
                    "http://octo.metacarta.com/cgi-bin/mapserv", 
                    {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'} 
                    );

        var added = map.addLayer(layer);
        t.ok(added === true, "Map.addLayer returns true if the layer is added to the map.");
        var added = map.addLayer(layer);
        t.ok(added === false, "Map.addLayer returns false if the layer is already present.");
    
        map.destroy();
    }

    function test_Map_setBaseLayer(t) {
        t.plan( 6 );
        
        map = new OpenLayers.Map('map');

        var wmslayer = new OpenLayers.Layer.WMS('Test Layer', 
                    "http://octo.metacarta.com/cgi-bin/mapserv", 
                    {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'}, 
                    {maxExtent: new OpenLayers.Bounds(33861, 717605, 330846, 1019656), maxResolution: 296985/1024, projection:"EPSG:2805" } );

        var wmslayer2 = new OpenLayers.Layer.WMS('Test Layer2', 
                    "http://octo.metacarta.com/cgi-bin/mapserv", 
                    {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'}, 
                    {maxExtent: new OpenLayers.Bounds(33861, 717605, 330846, 1019656), maxResolution: 296985/1024, projection:"EPSG:2805" } );

        map.addLayers([wmslayer, wmslayer2]);

        t.ok(map.baseLayer == wmslayer, "default base layer is first one added");
        
        map.setBaseLayer(null);
        t.ok(map.baseLayer == wmslayer, "setBaseLayer on null object does nothing (and does not break)");
        
        map.setBaseLayer("chicken");
        t.ok(map.baseLayer == wmslayer, "setBaseLayer on non-layer object does nothing (and does not break)");
        
        map.setBaseLayer(wmslayer2);
        t.ok(map.baseLayer == wmslayer2, "setbaselayer correctly sets 'baseLayer' property");

        map.destroy();

        var l1 = new OpenLayers.Layer(),
            l2 = new OpenLayers.Layer(null, {maxResolution: 1.4});
        map = new OpenLayers.Map({
            div: 'map',
            allOverlays: true,
            layers: [l1, l2],
            zoom: 0,
            center: [0, 0]
        });
        t.eq(l2.div.style.display, "none", "Layer invisible because not in range");
        map.raiseLayer(l1, 1);
        t.eq(l2.div.style.display, "block", "Layer visible after base layer change because in range now");
        map.destroy();
    }
    
    function test_Map_removeLayer(t) {
        t.plan(1);
        var f = function() {};
        var events = {triggerEvent: f};
        var layers = [
            {name: "fee", removeMap: f, events: events},
            {name: "fi", removeMap: f, events: events},
            {name: "fo", removeMap: f, events: events},
            {name: "fum", removeMap: f, events: events}
        ];
        var map = {
            layers: layers,
            baseLayer: layers[0],
            layerContainerDiv: {removeChild: f},
            events: {triggerEvent: f},
            resetLayersZIndex: function() {}
        };
        OpenLayers.Map.prototype.removeLayer.apply(map, [map.baseLayer, false]);
        t.eq(map.baseLayer, null,
             "removing the baselayer sets baseLayer to null");        
    }

    function test_Map_removeLayer_res(t) {
        t.plan(2);
        
        map = new OpenLayers.Map('map');

        var layer0 = new OpenLayers.Layer.WMS(
            'Test Layer 0', 
            "http://octo.metacarta.com/cgi-bin/mapserv", 
            {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'}, 
            {resolutions: [4, 2, 1]}
        );

        var layer1 = new OpenLayers.Layer.WMS(
            'Test Layer 1', 
            "http://octo.metacarta.com/cgi-bin/mapserv", 
            {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'}, 
            {resolutions: [4, 2]}
        );

        map.addLayers([layer0, layer1]);
        map.zoomToMaxExtent();
        map.zoomTo(2);
        t.eq(map.getResolution(), layer0.resolutions[2],
             "correct resolution before removal");
        map.removeLayer(layer0);
        t.eq(map.getResolution(), layer0.resolutions[1],
             "correct resolution after removal");

        map.destroy();
    }

    function test_Map_removeLayer_zindex(t) {
        t.plan(2);
        
        map = new OpenLayers.Map('map');

        var layer0 = new OpenLayers.Layer('Test Layer 0', {isBaseLayer:true});
        var layer1 = new OpenLayers.Layer('Test Layer 1', {isBaseLayer:true});
        var layer2 = new OpenLayers.Layer('Test Layer 2', {isBaseLayer:false});

        map.addLayers([layer0, layer1, layer2]);
        map.removeLayer(layer0);

        t.eq(parseInt(layer1.div.style.zIndex), map.Z_INDEX_BASE['BaseLayer'],
             "correct z-index after removeLayer");
        t.eq(parseInt(layer2.div.style.zIndex), map.Z_INDEX_BASE['Overlay'] + 5,
             "correct z-index after removeLayer");

        map.destroy();
    }
    
	function test_Map_removeLayer_preremovelayer(t) {
        t.plan(4);
        map = new OpenLayers.Map('map');
		
        map.addLayer(new OpenLayers.Layer());
        map.removeLayer(map.layers[0]);
        
        // one test: standard behaviour without listener
        t.eq(map.layers.length, 0, "without registered preremovelayer-listener layers can be removed as usual");
        
        var callCnt = 0;
        
        map.events.register('preremovelayer', this, function(evt) {
            callCnt++;
            return !(evt.layer.name === 'donotremove');
        });
        var layer1 = new OpenLayers.Layer('donotremove');
        var layer2 = new OpenLayers.Layer('doremove');
		
        map.addLayers([layer1,layer2]);
		
        // two tests: remove action can be canceled
        map.removeLayer(layer1);
        t.eq(map.layers.length, 2, "layer is not removed since preremovelayer returns false");
        map.removeLayer(layer2);
        t.eq(map.layers.length, 1, "layer is removed since preremovelayer returns true");
        
        // one test: listener was called twice
        t.eq(callCnt, 2, "preremovelayer-listener was called exactly twice");
        
        map.destroy();
	}
    
    function test_Map_setBaseLayer_after_pan (t) {
        t.plan(1);

        map = new OpenLayers.Map('map');
        var wmsLayer = new OpenLayers.Layer.WMS( "OpenLayers WMS", 
            "http://labs.metacarta.com/wms/vmap0", {layers: 'basic'} );
        var tmsLayer = new OpenLayers.Layer.TMS("TMS",
                                    "http://labs.metacarta.com/wms-c/Basic.py/",
                                    {'layername':'basic', 'type':'png'});
        map.addLayers([wmsLayer,tmsLayer]);
        map.setBaseLayer(wmsLayer);
        map.zoomToMaxExtent();
        map.setBaseLayer(tmsLayer);
        map.zoomIn();
        map.pan(0, -200, {animate:false});
        var log = [];
        map.applyTransform = function(x, y, scale) {
            log.push([x || map.layerContainerOriginPx.x, y || map.layerContainerOriginPx.y, scale]);
            OpenLayers.Map.prototype.applyTransform.apply(this, arguments);
        };
        map.setBaseLayer(wmsLayer);
        t.eq(log[0][0], 0, "layerContainer is recentered after setBaseLayer");
        
        map.destroy();
    }

    function test_Map_moveLayer (t) {
        t.plan(10);

        var ct  = 0;
        map = new OpenLayers.Map('map');
        var wmslayer = new OpenLayers.Layer.WMS('Test Layer', 
                    "http://octo.metacarta.com/cgi-bin/mapserv", 
                    {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'}, 
                    {maxExtent: new OpenLayers.Bounds(33861, 717605, 330846, 1019656), maxResolution: 296985/1024, projection:"EPSG:2805" } );

        var wmslayer2 = new OpenLayers.Layer.WMS('Test Layer2', 
                    "http://octo.metacarta.com/cgi-bin/mapserv", 
                    {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'}, 
                    {maxExtent: new OpenLayers.Bounds(33861, 717605, 330846, 1019656), maxResolution: 296985/1024, projection:"EPSG:2805" } );

        var wmslayer3 = new OpenLayers.Layer.WMS('Test Layer2', 
                    "http://octo.metacarta.com/cgi-bin/mapserv", 
                    {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'}, 
                    {maxExtent: new OpenLayers.Bounds(33861, 717605, 330846, 1019656), maxResolution: 296985/1024, projection:"EPSG:2805" } );

        map.addLayers([wmslayer, wmslayer2, wmslayer3]);
        map.events.register("changelayer", map, function (e) { ct++; });
        t.eq( map.getNumLayers(), 3, "getNumLayers returns the number of layers" );
        t.eq( map.getLayerIndex(wmslayer3), 2, "getLayerIndex returns the right index" );
        map.raiseLayer(wmslayer3, 1);
        t.eq( map.getLayerIndex(wmslayer3), 2, "can't moveLayer up past the top of the stack" );
        map.raiseLayer(wmslayer, -1);
        t.eq( map.getLayerIndex(wmslayer), 0, "can't moveLayer down past the bottom of the stack" );
        map.raiseLayer(wmslayer3, -1);
        t.eq( map.getLayerIndex(wmslayer3), 1, "can moveLayer down from the top" );
        t.eq( parseInt(wmslayer3.div.style.zIndex), map.Z_INDEX_BASE['BaseLayer'] + 5,
            "layer div has the right zIndex after moving down" );
        map.raiseLayer(wmslayer, 2);
        t.eq( map.getLayerIndex(wmslayer), 2, "can moveLayer up from the bottom" );
        t.eq( parseInt(wmslayer.div.style.zIndex), map.Z_INDEX_BASE['BaseLayer'] + 2 * 5,
            "layer div has the right zIndex after moving up" );
        t.eq( map.getLayerIndex(wmslayer3), 0, "top layer is now on the bottom" );
        t.eq( ct, 3, "raiseLayer triggered changelayer the right # of times" );

        map.destroy();
    }

    function test_Map_moveTo(t) {
        t.plan(2);

        map = new OpenLayers.Map('map');
        var baseLayer = new OpenLayers.Layer.WMS("Test Layer", 
            "http://octo.metacarta.com/cgi-bin/mapserv?",
            {map: "/mapdata/vmap_wms.map", layers: "basic"},
            {maxResolution: 'auto', maxExtent: new OpenLayers.Bounds(-10,-10,10,10)});
        baseLayer.events.on({
            move: function() {
                t.ok(true, "move listener called");
            },
            movestart: function(e) {
                t.eq(e.zoomChanged, true, "movestart listener called with expected value");
            }
        });
        baseLayer.events.on({
            moveend: function(e) {
                t.eq(e.zoomChanged, true, "moveend listener called with expected value");
            }
        });
        map.addLayer(baseLayer);
        var ll = new OpenLayers.LonLat(-100,-150);
        map.moveTo(ll, 2);
        t.ok(map.getCenter().equals(new OpenLayers.LonLat(0,0)), "safely sets out-of-bounds lonlat");

        map.destroy();
    }

    function test_Map_defaultTheme(t) {
        t.plan(5);
        
        var links = document.getElementsByTagName('link');
        map = new OpenLayers.Map('map');
        var gotNodes = 0;
        var themeNode = null;
        for(var i=0; i<links.length; ++i) {
            if(OpenLayers.Util.isEquivalentUrl(map.theme, links.item(i).href)) {
                gotNodes += 1;
                themeNode = links.item(i);
            }
        }
        t.eq(gotNodes, 1, "by default, a single link node is added to document");
        t.ok(themeNode != null, "a link node with the theme href was added");
        t.eq(themeNode.rel, "stylesheet", "node added has rel set to stylesheet");
        t.eq(themeNode.type, "text/css", "node added has type set to text/css");
        
        // reconstruct the map to prove that another link is not added
        map = new OpenLayers.Map('map');
        t.eq(links.length, document.getElementsByTagName('link').length,
             "calling the map constructor twice with the same theme doesn't add duplicate link nodes");

        map.destroy();
    }

    function test_Map_customTheme(t) {
        t.plan(5);
        
        var customTheme = 'foo';
        var options = {theme: customTheme};
        map = new OpenLayers.Map('map', options);

        var links = document.getElementsByTagName('link');
        var gotNodes = 0;
        var themeNode = null;
        for(var i=0; i<links.length; ++i) {
            if(OpenLayers.Util.isEquivalentUrl(map.theme, links.item(i).href)) {
                gotNodes += 1;
                themeNode = links.item(i);
            }
        }
        
        t.eq(map.theme, customTheme, "map theme is properly set");
        t.eq(gotNodes, 1, "with custom theme, a single link node is added to document");
        t.ok(themeNode != null, "a link node with the theme href was added");
        t.eq(themeNode.rel, "stylesheet", "node added has rel set to stylesheet");
        t.eq(themeNode.type, "text/css", "node added has type set to text/css");
        
        map.destroy();
    }

    function test_Map_noTheme(t) {
        t.plan(1);
        
        var head = document.getElementsByTagName('head')[0];
        var nodeCount = head.childNodes.length;
        
        var options = {theme: null};
        map = new OpenLayers.Map('map', options);

        t.eq(nodeCount, head.childNodes.length, "with no theme, a node is not added to document head" );

        map.destroy();
    }

    function test_Map_addControls(t) {
        t.plan(5);
        var map = new OpenLayers.Map('map', {
            controls: []
        });
        var controls = [
          new OpenLayers.Control({id:'firstctrl'}),
          new OpenLayers.Control({id:'secondctrl'})
        ];
        map.addControls(controls);
        t.eq(map.controls.length, 2, "two controls were added by map.addControls without a px-array");
        t.eq(map.controls[0].id, 'firstctrl', "control with index 0 has id 'firstctrl'");
        t.eq(map.controls[1].id, 'secondctrl', "control with index 1 has id 'secondctrl'");
        
        var controls2 = [
          new OpenLayers.Control({id:'thirdctrl'}),
          new OpenLayers.Control({id:'fourthctrl'}),
          new OpenLayers.Control({id:'fifthctrl'})
        ];
        // this array is intentionally one element shorter than the above       
        var pixels2 = [
          null,
          new OpenLayers.Pixel(27,11)
        ];
        map.addControls(controls2, pixels2);
        t.eq(map.controls.length, 5, "three additional controls were added by map.addControls with a px-array");
        t.eq(map.controls[3].position.toString(), pixels2[1].toString(), "control 'fourthctrl' has position set to given px");

        map.destroy();
    }

    function test_Map_getControl(t) {
        t.plan(2);
        
        var map1 = new OpenLayers.Map('map');
        
        var control = new OpenLayers.Control();
        map1.addControl(control);

        var gotControl = map1.getControl(control.id);
        t.ok(gotControl == control, "got right control");
        
        gotControl = map1.getControl("bogus id");
        t.ok(gotControl == null, "getControl() for bad id returns null");

        map1.destroy();
    }

    function test_Map_removeControl(t) {
        t.plan(6);
        
        var oldNumControls, newNumControls;
        
        var map1 = new OpenLayers.Map('map');
        oldNumControls = map1.controls.length;
        
        var control = new OpenLayers.Control();
        map1.addControl(control);

    //add control        
        newNumControls = map1.controls.length;
        t.ok( newNumControls = oldNumControls + 1, "adding a control increases control count")

        var foundDiv = false;
        for(var i=0; i < map1.viewPortDiv.childNodes.length; i++) {
            var childNode = map1.viewPortDiv.childNodes[i];
            if (childNode == control.div) {
                foundDiv = true;
            }
        }
        t.ok(foundDiv, "new control's div correctly added to viewPort");

    //remove control        
        map1.removeControl(control)
        newNumControls = map1.controls.length;
        t.ok( newNumControls == oldNumControls, "removing the control decreases control count")

        var gotControl = map1.getControl(control.id);
        t.ok( gotControl == null, "control no longer in map's controls array");

        var foundDiv = false;
        for(var i=0; i < map1.viewPortDiv.childNodes.length; i++) {
            var childNode = map1.viewPortDiv.childNodes[i];
            if (childNode == control.div) {
                foundDiv = true;
            }
        }
        t.ok(!foundDiv, "control no longer child of viewPort");

    //remove bogus
        control = { id: "bogus id" };
        map1.removeControl(control);
        newNumControls = map1.controls.length;
        t.ok( newNumControls == oldNumControls, "removing bad controlid doesnt crash or decrease control count")

        map1.destroy();

    }

    function test_Map_restrictedExtent(t) {
        t.plan(25);
        var extent = new OpenLayers.Bounds(-180, -90, 180, 90);
        var options = {
            maxResolution: "auto"
        };
        var map = new OpenLayers.Map("map", options);
        var layer = new OpenLayers.Layer.WMS(
            "test", 
            "http://octo.metacarta.com/cgi-bin/mapserv?",
            {map: "/mapdata/vmap_wms.map", layers: "basic"}
        );
        map.addLayer(layer);
        map.zoomToMaxExtent();
        var nw = new OpenLayers.LonLat(extent.left, extent.top);
        var ne = new OpenLayers.LonLat(extent.right, extent.top);
        var sw = new OpenLayers.LonLat(extent.left, extent.bottom);
        var se = new OpenLayers.LonLat(extent.right, extent.bottom);
        
        // try panning to northwest corner
        map.setOptions({restrictedExtent: extent});
        map.setCenter(nw, 0);
        t.eq(map.getExtent().getCenterLonLat().toString(),
             extent.getCenterLonLat().toString(),
             "map extent properly restricted to northwest at zoom 0");
        t.eq(map.zoom, 0, "zoom not restricted for nw, 0");
        map.setCenter(nw, 5);
        t.eq(map.getExtent().top, extent.top,
             "map extent top properly restricted to northwest at zoom 5");
        t.eq(map.getExtent().left, extent.left,
             "map extent left properly restricted to northwest at zoom 5");
        t.eq(map.zoom, 5, "zoom not restricted for nw, 5");
        map.setOptions({restrictedExtent: null});
        map.setCenter(nw, 0);
        t.eq(map.getExtent().getCenterLonLat().toString(),
             nw.toString(),
             "map extent not restricted with null restrictedExtent for nw");

        // try panning to northeast corner
        map.setOptions({restrictedExtent: extent});
        map.setCenter(ne, 0);
        t.eq(map.getExtent().getCenterLonLat().toString(),
             extent.getCenterLonLat().toString(),
             "map extent properly restricted to northeast at zoom 0");
        t.eq(map.zoom, 0, "zoom not restricted for ne, 0");
        map.setCenter(ne, 5);
        t.eq(map.getExtent().top, extent.top,
             "map extent top properly restricted to northeast at zoom 5");
        t.eq(map.getExtent().right, extent.right,
             "map extent right properly restricted to northeast at zoom 5");
        t.eq(map.zoom, 5, "zoom not restricted for ne, 5");
        map.setOptions({restrictedExtent: null});
        map.setCenter(ne, 0);
        t.eq(map.getExtent().getCenterLonLat().toString(),
             ne.toString(),
             "map extent not restricted with null restrictedExtent for ne");
        
        // try panning to southwest corner
        map.setOptions({restrictedExtent: extent});
        map.setCenter(sw, 0);
        t.eq(map.getExtent().getCenterLonLat().toString(),
             extent.getCenterLonLat().toString(),
             "map extent properly restricted to southwest at zoom 0");
        t.eq(map.zoom, 0, "zoom not restricted for sw, 0");
        map.setCenter(sw, 5);
        t.eq(map.getExtent().bottom, extent.bottom,
             "map extent bottom properly restricted to southwest at zoom 5");
        t.eq(map.getExtent().left, extent.left,
             "map extent left properly restricted to southwest at zoom 5");
        t.eq(map.zoom, 5, "zoom not restricted for sw, 5");
        map.setOptions({restrictedExtent: null});
        map.setCenter(sw, 0);
        t.eq(map.getExtent().getCenterLonLat().toString(),
             sw.toString(),
             "map extent not restricted with null restrictedExtent for sw");

        // try panning to southeast corner
        map.setOptions({restrictedExtent: extent});
        map.setCenter(se, 0);
        t.eq(map.getExtent().getCenterLonLat().toString(),
             extent.getCenterLonLat().toString(),
             "map extent properly restricted to southeast at zoom 0");
        t.eq(map.zoom, 0, "zoom not restricted for se, 0");
        map.setCenter(se, 5);
        t.eq(map.getExtent().bottom, extent.bottom,
             "map extent bottom properly restricted to southeast at zoom 5");
        t.eq(map.getExtent().right, extent.right,
             "map extent right properly restricted to southeast at zoom 5");
        t.eq(map.zoom, 5, "zoom not restricted for se, 5");
        map.setOptions({restrictedExtent: null});
        map.setCenter(se, 0);
        t.eq(map.getExtent().getCenterLonLat().toString(),
             se.toString(),
             "map extent not restricted with null restrictedExtent for se");

        map.destroy();

        extent = new OpenLayers.Bounds(8, 44.5, 19, 50);
        var options = {
            restrictedExtent: extent,
            zoomMethod: null
        };
        map = new OpenLayers.Map('map', options);

        var wms = new OpenLayers.Layer.WMS(
            "OpenLayers WMS", 
            "http://vmap0.tiles.osgeo.org/wms/vmap0?",
            {layers: 'basic'}
        ); 

        map.addLayers([wms]);
        map.zoomToExtent(extent);
        map.zoomIn();
        map.setOptions({restrictedExtent: null});
        map.pan(-250, -250);
        t.ok((map.getExtent().bottom == 48.3486328125 && map.getExtent().left == 7.45751953125), "Expected extent when toggling restrictedExtent");
        map.destroy();
    }

    function test_Map_getResolutionForZoom(t) {
        t.plan(2);
        var map = new OpenLayers.Map("map");
        var res = map.getResolutionForZoom();
        t.eq(res, null, "getResolutionForZoom returns null for no base layer");
        map.fractionalZoom = true;
        var layer = new OpenLayers.Layer("test", {isBaseLayer: true});
        map.addLayer(layer);
        layer.getResolutionForZoom = function() {
            t.ok(true, "getResolutionForZoom calls base layer getResolutionForZoom");
        }
        var res = map.getResolutionForZoom();
        layer.destroy();
        map.destroy();
    }
    
    function test_zoomTo(t) {
        t.plan(8);
        
        var map = new OpenLayers.Map("map", {zoomMethod: null});
        map.addLayer(new OpenLayers.Layer(null, {
            isBaseLayer: true
        }));
        
        map.zoomToMaxExtent();
        
        map.zoomTo(2);
        t.eq(map.getZoom(), 2, 'zoomTo(2)');

        map.zoomTo(3.6);
        t.eq(map.getZoom(), 4, 'zoomTo(3.6)');
        
        map.zoomTo("4.6");
        t.eq(map.getZoom(), 5, 'zoomTo("4.6")');
        
        map.zoomTo("1.2");
        t.eq(map.getZoom(), 1, 'zoomTo("1.2")');
        
        // now allow fractional zoom
        map.fractionalZoom = true;
        
        map.zoomTo(2);
        t.eq(map.getZoom(), 2, '[fractionalZoom] zoomTo(2)');

        map.zoomTo(3.6);
        t.eq(map.getZoom(), 3.6, '[fractionalZoom] zoomTo(3.6)');
        
        map.zoomTo("4.6");
        t.eq(map.getZoom(), 4.6, '[fractionalZoom] zoomTo("4.6")');
        
        map.zoomTo("1.2");
        t.eq(map.getZoom(), 1.2, '[fractionalZoom] zoomTo("1.2")');
        
        map.destroy();
    }
    
    function test_zoomTo_animated(t) {
        t.plan(2);
        
        var map = new OpenLayers.Map("map");
        map.addLayer(new OpenLayers.Layer(null, {
            isBaseLayer: true
        }));
        
        map.zoomToMaxExtent();
        
        map.zoomTo(2);
        map.zoomIn();
        map.zoomOut();
        map.zoomIn();
        t.delay_call(2, function() {
            t.eq(map.getZoom(), 3, '[fractionalZoom: false] zoomTo(2) - zoomIn() - zoomOut() - zoomIn()');

            // now allow fractional zoom
            map.fractionalZoom = true;

            map.zoomTo(2.6);
            map.zoomIn();
            map.zoomOut();
            map.zoomIn();
        });
        t.delay_call(4, function() {
            t.eq(map.getZoom(), 3.6, '[fractionalZoom: true] zoomTo(2) - zoomIn() - zoomOut() - zoomIn()');
            map.destroy();
        });
        
    }
    
    function test_Map_getUnits(t) {
        t.plan(2);
        var map = new OpenLayers.Map("map");
        var units = map.getUnits();
        t.eq(units, null, "getUnits returns null for no base layer");
        
        var layer = new OpenLayers.Layer("test", {
            isBaseLayer: true,
            units: 'foo'
        });
        map.addLayer(layer);
        var units = map.getUnits();
        t.eq(units, 'foo', "getUnits returns the base layer units property");
        layer.destroy();
        map.destroy();
    }

    function test_Map_destroy (t) {
        t.plan( 3 );    
        map = new OpenLayers.Map('map');
        map.destroy();
        t.eq( map.layers, null, "map.layers is null after destroy" );
        t.eq( map.controls, null, "map.controls is null after destroy" );
        t.eq( map.viewPortDiv, null, "map's viewportDiv nullified");
    }

    function test_Map_getMaxExtent(t){
        t.plan(5);

        var options = null;
        var map = {};

      //null options, no baseLayer
        var maxExtent = OpenLayers.Map.prototype.getMaxExtent.apply(map, [options]);
        t.eq(maxExtent, null, "null options, no baseLayer returns null");     

      //null options.restricted, no baseLayer
        maxExtent = OpenLayers.Map.prototype.getMaxExtent.apply(map, [options]);
        t.eq(maxExtent, null, "null options.restricted, no baseLayer returns null");     

      //true options.restricted, null map.restrictedExtent no baseLayer
        maxExtent = OpenLayers.Map.prototype.getMaxExtent.apply(map, [options]);
        t.eq(maxExtent, null, "true options.restricted, null map.restrictedExtent no baseLayer returns null");     

      //true options.restricted, valid map.restrictedExtent no baseLayer
        options = {
            'restricted': true
        };
        map.restrictedExtent = {};
        maxExtent = OpenLayers.Map.prototype.getMaxExtent.apply(map, [options]);
        t.ok(maxExtent == map.restrictedExtent, "true options.restricted, valid map.restrictedExtent no baseLayer returns map.restrictedExtent");     

      //null options, valid baseLayer
        options = null;
        map.baseLayer = {
            'maxExtent': {}
        };
        var maxExtent = OpenLayers.Map.prototype.getMaxExtent.apply(map, [options]);
        t.ok(maxExtent == map.baseLayer.maxExtent, "null options, valid baseLayer returns map.baseLayer.maxExtent");     
    }
    
    function test_Map_zoomToMaxExtent(t){
        t.plan(4)

        gMaxExtent = {};

        var map = {
            'getMaxExtent': function(options) {
                gRestricted = options.restricted; 
                return gMaxExtent;
            }, 
            'zoomToExtent': function(extent) {
                t.ok(extent == gMaxExtent, "zoomToExtent() always called on return from map.getMaxExtent()");
            } 
        };

      //options is null
        var options = null;
        gRestricted = null;
        OpenLayers.Map.prototype.zoomToMaxExtent.apply(map, [options]);
        t.eq(gRestricted, true, "default 'restricted' passed to map.getMaxExtent() is true");
        
      //valid options
        options = {
            'restricted': {}
        };
        gRestricted = null;
        OpenLayers.Map.prototype.zoomToMaxExtent.apply(map, [options]);
        t.ok(gRestricted == options.restricted, "when valid options argument, 'options.restricted' passed to map.getMaxExtent()");
    }

    function test_Map_zoomToScale(t) {
        t.plan(4);
        
        var m = {
            'baseLayer': { 'units': {} },
            'size': {'w': 10, 'h': 15},
            'getSize': function() { return {'w': 10, 'h': 15}; },
            'getCachedCenter': function() { return {'lon': -5, 'lat': -25}; },
            'zoomToExtent': function(extent, closest) {
                t.ok(extent.equals(g_ExpectedExtent), "extent correctly calculated for zoomToExtent()");
                t.ok(closest == g_Closest, "closest correctly passed on to zoomToExtent()");
            }            
        }

        var temp = OpenLayers.Util.getResolutionFromScale;
        OpenLayers.Util.getResolutionFromScale = function(scale, units) {
            t.ok(scale == g_Scale, "scale parameter correctly passed to getResolutionFromScale");
            t.ok(units == m.baseLayer.units, "map's baselayer's units parameter correctly passed to getResolutionFromScale");
            return 1000;
        };
 
        g_ExpectedExtent = new OpenLayers.Bounds(-5005,-7525,4995,7475);
        g_Scale = {};
        g_Closest = {};
        var args = [g_Scale, g_Closest];
        OpenLayers.Map.prototype.zoomToScale.apply(m, args);    

        OpenLayers.Util.getResolutionFromScale = temp;
    }
    
    function test_Map_zoomToExtent(t) {
        t.plan(12);
        
        var map = new OpenLayers.Map("map");
        var layer = new OpenLayers.Layer(null, {isBaseLayer: true});
        map.addLayer(layer);
        
        var bounds = new OpenLayers.Bounds(-160, 15, -50, 69);
        var center;
        
        // default for closest
        map.zoomToExtent(bounds);
        center = map.getCenter();
        t.eq(center.lon, -105, "a) correct x");
        t.eq(center.lat, 42, "a) correct y");
        t.eq(map.getZoom(), 2, "a) correct zoom");

        // false for closest
        map.zoomToExtent(bounds, false);
        center = map.getCenter();
        t.eq(center.lon, -105, "b) correct x");
        t.eq(center.lat, 42, "b) correct y");
        t.eq(map.getZoom(), 2, "b) correct zoom");

        // true for closest
        map.zoomToExtent(bounds, true);
        center = map.getCenter();
        t.eq(center.lon, -105, "c) correct x");
        t.eq(center.lat, 42, "c) correct y");
        t.eq(map.getZoom(), 3, "c) correct zoom");

        // accept array
        map.zoomToExtent([-160, 15, -50, 69]);
        center = map.getCenter();
        t.eq(center.lon, -105, "(array) correct x");
        t.eq(center.lat, 42, "(array) correct y");
        t.eq(map.getZoom(), 2, "(array) correct zoom");
        
        map.destroy();
    }

    function test_Map_zoomToExtent_wrapped(t) {
        t.plan(9);
        
        var map = new OpenLayers.Map("map");
        var layer = new OpenLayers.Layer(null, {isBaseLayer: true, wrapDateLine: true});
        map.addLayer(layer);
        
        var bounds, center;
        
        var cases = [{
            // real world
            bbox: [120, -20, 140, 0],
            center: [130, -10]
        }, {
            // one world to the right
            bbox: [220, -45, 240, 45],
            center: [-130, 0]
        }, {
            // two worlds to the right
            bbox: [550, -15, 560, 5],
            center: [-165, -5]
        }, {
            // one world to the left
            bbox: [-240, -15, -220, 5],
            center: [130, -5]
        }, {
            // two worlds to the left
            bbox: [-600, -15, -580, 5],
            center: [130, -5]
        }];
        
        var num = cases.length;
        t.plan(num * 2);
        
        var c, bounds, center;
        for (var i=0; i<num; ++i) {
            c = cases[i];
            bounds = OpenLayers.Bounds.fromArray(c.bbox);
            map.zoomToExtent(bounds);
            center = map.getCenter();
            t.eq(center.lon, c.center[0], "y: " + bounds);
            t.eq(center.lat, c.center[1], "x: " + bounds);
        }
        
        map.destroy();
    }

    
    function test_allOverlays(t) {
        
        t.plan(18);

        var map = new OpenLayers.Map({
            div: "map", allOverlays: true
        });
        
        var a = new OpenLayers.Layer.Vector("a", {visibility: true});

        var b = new OpenLayers.Layer.Image(
            "b",
            "http://earthtrends.wri.org/images/maps/4_m_citylights_lg.gif",
            new OpenLayers.Bounds(-180, -88.759, 180, 88.759),
            new OpenLayers.Size(580, 288)
        );

        var c = new OpenLayers.Layer.WMS(
            "c",
            "http://labs.metacarta.com/wms/vmap0",
            {layers: 'basic'}
        );

        var d = new OpenLayers.Layer.Vector("d");
        
        map.addLayers([a, b, c, d]);

        var moveCount = 0;
        a.moveTo = function() {
            moveCount++;
            OpenLayers.Layer.Vector.prototype.moveTo.apply(this, arguments);
        };

        map.zoomToMaxExtent();
        t.eq(moveCount, 1, "map.moveTo moves the base layer only once");
        t.eq(map.getCenter().toString(), "lon=0,lat=0", "a map with all overlays can have a center");

        a.setVisibility(false);
        var moveend = 0;
        a.events.on({"moveend": function() { moveend++; }}); 
        map.zoomToMaxExtent();
        t.eq(moveCount, 1, "map.moveTo does not move the base layer if it is invisible");
        t.eq(moveend, 0, "map.moveTo does not trigger \"moveend\" in the layer if the layer is invisible");
        a.setVisibility(true);
        
        // a, b, c, d
        t.eq(map.baseLayer.name, "a", "base layer set to first layer added");
        
        map.removeLayer(a);
        // b, c, d
        t.eq(map.baseLayer.name, "b", "if base layer is removed, lowest layer becomes base");
        
        map.addLayer(a);
        // b, c, d, a
        t.eq(map.baseLayer.name, "b", "adding a new layer doesn't change base layer");
        
        map.setLayerIndex(c, 1);
        // b, d, c, a
        t.eq(map.baseLayer.name, "b", "changing layer order above base doesn't mess with base");
        
        map.setLayerIndex(d, 0);
        // d, b, c, a
        t.eq(map.baseLayer.name, "d", "changing layer order to 0 sets base layer");
        
        map.raiseLayer(d, 1);
        // b, d, c, a
        t.eq(map.baseLayer.name, "b", "raising the base layer sets a new base layer");
        
        map.raiseLayer(d, -1);
        // d, b, c, a
        t.eq(map.baseLayer.name, "d", "lowering a layer to lowest index sets as base");
        
        // all this switching of base layer didn't muck with layer visibility
        t.eq(a.visibility, true, "a is visible");
        t.eq(b.visibility, true, "b is visible");
        t.eq(c.visibility, true, "c is visible");
        t.eq(d.visibility, true, "d is visible");
        
        // test that map can have an invisible base layer
        b.setVisibility(false);
        map.setLayerIndex(b, 0);
        t.eq(b.visibility, false, "changing layer order doesn't change visibility");

       
        map.destroy();
        
        // make sure setVisibility is called when adding a single layer to the map
        map = new OpenLayers.Map({
            div: "map", allOverlays: true
        });
        var count = 0;
        var layer = new OpenLayers.Layer(null, {
            visibility: true,
            maxExtent: new OpenLayers.Bounds(-180, -90, 180, 90),
            setVisibility: function() {
                ++count;
                OpenLayers.Layer.prototype.setVisibility.apply(this, arguments);
            }
        });
        map.addLayer(layer);
        map.zoomToMaxExtent();
        
        t.eq(count, 1, "setVisibility called when visibility is true in layer config");
        t.eq(layer.div.style.display, "", "layer is visible.");

        map.destroy();
        
    }
    
    function test_panTo(t) {
        
        t.plan(6);
        
        var log = [];
        var map = new OpenLayers.Map("map", {
            eventListeners: {
                "movestart": function() {log.push("movestart");},
                "move": function() {log.push("move");},
                "moveend": function() {log.push("moveend");}
            }            
        });
        map.addLayer(
            new OpenLayers.Layer(null, {isBaseLayer: true})
        );
        map.setCenter(new OpenLayers.LonLat(0, 0), 0);
        t.eq(log[log.length-1], "moveend", "moveend fired when map center is set");
        log = [];
        
        map.panTo(new OpenLayers.LonLat(1, 0));
        t.eq(map.panTween.playing, true, "the map pan tween is playing before destroy");
        
        t.delay_call(2, function() {
            t.eq(log[0], "movestart", "panTo starts with movestart event");
            t.eq(log[1], "move", "move events fired while panning");
            t.eq(log[log.length-1], "moveend", "panTo finishes with moveend event");
            map.destroy();
            t.ok(!map.panTween || !map.panTween.playing, "the map pan tween is not playing after destroy");
        });
    }
    
    function test_pan(t) {
        t.plan(4);
        
        var map = new OpenLayers.Map("map");
        map.addLayer(
            new OpenLayers.Layer(null, {isBaseLayer: true})
        );
        map.setCenter(new OpenLayers.LonLat(0, 0), 5);
        var log = [];
        map.events.on({
            "movestart": function() {log.push("movestart");},
            "move": function() {log.push("move");},
            "moveend": function() {log.push("moveend");}
        });
        
        // simulate the drag sequence of the DragPan control;
        map.pan(5,5, {animate: false, dragging: true});
        map.pan(1,1, {animate: false, dragging: false});
        
        t.eq(log[0], "movestart", "pan sequence starts with movestart");
        t.eq(log[1], "move", "followed by move,");
        t.eq(log[log.length-2], "move", "move again before we stop panning,");
        t.eq(log[log.length-1], "moveend", "and moveend when we're done.");
    }

    function test_pan_no_anim_event_sequence(t) {
        t.plan(4);

        var log = [];
        var map = new OpenLayers.Map("map");
        map.addLayer(
            new OpenLayers.Layer(null, {isBaseLayer: true})
        );
        map.setCenter(new OpenLayers.LonLat(0, 0), 5);
        map.events.on({
            "movestart": function() {
                log.push("movestart");
            },
            "move": function() {
                log.push("move");
            },
            "moveend": function() {
                log.push("moveend");
            }
        });

        map.pan(5,5, {animate: false});
        t.eq(log.length, 3, "no more than 3 events happen.");
        t.eq(log[0], "movestart", "pan sequence starts with movestart");
        t.eq(log[1], "move", "followed by move,");
        t.eq(log[2], "moveend", "and moveend when we're done.");

        map.destroy();
    }

    // test if we can call updateSize before document.body is ready. updateOk
    // is tested in the test_updateSize function below
    var earlyMap = new OpenLayers.Map();
    var updateOk;
    try {
      earlyMap.updateSize();
      updateOk = true;
    } catch(e) {}
    earlyMap.destroy();
    function test_updateSize(t) {
        t.plan(3);

        // checking updateSize from outside this test function (see above)
        t.ok(updateOk, "updateSize works before document.body is ready");

        var map, moveToCnt, size;

        map = new OpenLayers.Map({div: "map"});
        map.addLayer(new OpenLayers.Layer("layer", {isBaseLayer: true}));

        map.moveTo = function() {
            moveToCnt++;
            OpenLayers.Map.prototype.moveTo.apply(this, arguments);
        };

        map.getCurrentSize = function() {
            return size;
        };

        // map has no center
        // 1 test
        moveToCnt = 0;
        size = new OpenLayers.Size(650, 350);
        map.updateSize();
        t.eq(moveToCnt, 0, "updateSize doesn't move the map if it doesn't have a center");

        // map has a center
        // 1 test
        map.zoomToMaxExtent();
        moveToCnt = 0;
        size = new OpenLayers.Size(600, 300);
        map.updateSize();
        t.eq(moveToCnt, 1, "updateSize move the map if it has a center");

        map.destroy();        
    }
    
    function test_invisible_map(t) {
        /** 
         * This test confirms that initializing a map using an element that is 
         * not currently displayed doesn't cause any trouble.
         */
        t.plan(1);
        
        var map, msg = "initializing a map on an undisplayed element";
        try {
            map = new OpenLayers.Map("invisimap");
        } catch (err) {
            msg += ": " + err;
        }
        t.ok(!!map, msg);
        
        if (map) {
            map.destroy();
        }        
    }
    
    function test_layers_option(t) {
        
        t.plan(3);

        var map = new OpenLayers.Map({
            div: "map",
            layers: [
                new OpenLayers.Layer()
            ]
        });
        
        t.eq(map.layers.length, 1, "single layer from options added");

        map.destroy();
        
        map = new OpenLayers.Map({
            div: "map",
            layers: [
                new OpenLayers.Layer(null, {isBaseLayer: true}),
                new OpenLayers.Layer(null, {isBaseLayer: false})
            ]
        });
        
        t.eq(map.layers.length, 2, "multiple layers added from options");
        t.ok(map.baseLayer, "map has a base layer");

        map.destroy();
        
    }
    
    function test_center_option(t) {
        t.plan(7);
        
        var map, msg;
        
        
        // try setting center without layers, this has no effect
        var failed = false;
        try {
            map = new OpenLayers.Map({
                div: "map",
                center: new OpenLayers.LonLat(1, 2)
            });
            msg = "center option without layers has no effect";
        } catch (err) {
            failed = true;
            msg = "center option without layers throws error";
        }
        t.ok(!failed, msg);
        
        if (map) {
            map.destroy();
        }
        
        var log = [];
        var meth = OpenLayers.Layer.prototype.moveTo;
        OpenLayers.Layer.prototype.moveTo = function() {
            log.push(arguments);
            meth.apply(this, arguments);
        };
        
        // set center without zoom
        var center = new OpenLayers.LonLat(1, 2);
        map = new OpenLayers.Map({
            div: "map",
            layers: [new OpenLayers.Layer(null, {isBaseLayer: true})],
            center: center
        });
        
        t.ok(center.equals(map.getCenter()), "map center set without zoom");
        t.eq(log.length, 1, "moveTo called once");
        
        map.destroy();
        OpenLayers.Layer.prototype.moveTo = meth;
        
        // set center and zoom
        var zoom = 3;
        map = new OpenLayers.Map({
            div: "map",
            layers: [new OpenLayers.Layer(null, {isBaseLayer: true})],
            center: center,
            zoom: zoom
        });

        t.ok(center.equals(map.getCenter()), "map center set with center and zoom");
        t.eq(zoom, map.getZoom(), "map zoom set with center and zoom");
        
        map.destroy();
        
        // set center and zoom with all overlays
        map = new OpenLayers.Map({
            div: "map",
            allOverlays: true,
            layers: [new OpenLayers.Layer()],
            center: center,
            zoom: zoom
        });
        
        t.ok(center.equals(map.getCenter()), "map center set with all overlays");
        t.eq(zoom, map.getZoom(), "map zoom set with all overlays");        
        
        map.destroy();
        
    }
    function test_pixel_lonlat(t) {
        
        t.plan(4);

        var map = new OpenLayers.Map({
            div: "map",
            layers: [
                new OpenLayers.Layer("name", {isBaseLayer:true})
            ]
        });
        map.zoomToMaxExtent();
        var px = map.getPixelFromLonLat(map.getLonLatFromPixel(new OpenLayers.Pixel(100, 100)));
        t.eq(px.x, 100, "x is the same in and ot");
        t.eq(px.y, 100, "y is the same in and out");
        var ll = map.getLonLatFromPixel(map.getPixelFromLonLat(new OpenLayers.LonLat(100, 100)));
        t.ok((ll.lon > (100 -map.getResolution()) && (ll.lon < (100 + map.getResolution()))), "lon is the same in and ot");
        t.ok((ll.lat > (100 -map.getResolution()) && (ll.lat < (100 + map.getResolution()))), "lat is the same in and ot");
        map.destroy();
    }    

    function test_moveByPx(t) {
        t.plan(14);

        var moved;
        var Layer = OpenLayers.Class(OpenLayers.Layer, {
            moveByPx: function(dx, dy) {
                moved[this.name] = true;
            }
        });

        var map = new OpenLayers.Map({
            div: 'map',
            maxExtent: new OpenLayers.Bounds(-50, -50, 50, 50),
            restrictedExtent: new OpenLayers.Bounds(-10, -10, 10, 10),
            layers: [
                new Layer('base',
                    {isBaseLayer: true}),
                new Layer('outofrange',
                    {isBaseLayer: false, minResolution:2})
            ]
        });
        var log = [];
        map.applyTransform = function(x, y, scale) {
            log.push([x || map.layerContainerOriginPx.x, y || map.layerContainerOriginPx.y, scale]);
            OpenLayers.Map.prototype.applyTransform.apply(this, arguments);
        };

        moved = {};
        map.zoomToExtent(new OpenLayers.Bounds(-1, -1, 1, 1));

        // check initial state
        t.eq(log[0][0], 0,
             '[initial state] layer container left correct');
        t.eq(log[0][1], 0,
             '[initial state] layer container top correct');
        t.eq(moved['base'], undefined,
             '[initial state] base layer not moved');
        t.eq(moved['outofrange'], undefined,
             '[initial state] out-of-range layer not moved');

        // move to a valid position
        moved = {};
        map.moveByPx(-455, 455);
        t.eq(log[1][0], 455,
             '[valid position] layer container left correct');
        t.eq(log[1][1], -455,
             '[valid position] layer container top correct');
        t.eq(moved['base'], true,
             '[valid position] base layer moved');
        t.eq(moved['outofrange'], undefined,
             '[valid position] out-of-range layer not moved');

        // move outside the max extent
        moved = {};
        map.moveByPx(-4500, 4500);
        t.eq(log.length, 2,
             '[outside max extent] layer container offset unchanged');
        t.eq(moved['base'], undefined,
             '[outside max extent] base layer not moved');
        t.eq(moved['outofrange'], undefined,
             '[outside max extent] out-of-range layer not moved');

        // move outside the restricted extent
        moved = {};
        map.moveByPx(-500, 500);
        t.eq(log.length, 2,
             '[outside restricted extent] layer container offset unchanged');
        t.eq(moved['base'], undefined,
             '[outside restricted extent] base layer not moved');
        t.eq(moved['outofrange'], undefined,
             '[outside restricted extent] out-of-range layer not moved');


        map.destroy();
    }

    // test for http://trac.osgeo.org/openlayers/ticket/3388
    function test_moveByPx_restrictedExtent(t) {
        t.plan(2);

        var map = new OpenLayers.Map({
            div: 'map',
            restrictedExtent: new OpenLayers.Bounds(-22.5,-11.25,22.5,11.25),
            layers: [
                new OpenLayers.Layer('name', {isBaseLayer: true})
            ]
        });

        map.zoomToExtent(new OpenLayers.Bounds(-11.25, 0, 11.25, 11.25));

        var log = [];
        map.applyTransform = function(x, y, scale) {
            log.push([x || map.layerContainerOriginPx.x, y || map.layerContainerOriginPx.y, scale]);
            OpenLayers.Map.prototype.applyTransform.apply(this, arguments);
        };

        map.moveByPx(-10, -10);
        t.eq(log[0][0], 10, 'layer container left correct');
        t.eq(log[0][1], 0, 'layer container top correct');
    }
    
    function test_applyTransform(t) {
        t.plan(10);
        var origStylePrefix = OpenLayers.Util.vendorPrefix.style;
        OpenLayers.Util.vendorPrefix.style =
                OpenLayers.Util.vendorPrefix.css =
                function(key) { return 'transform'; };
        
        var map = new OpenLayers.Map('map');
        map.layerContainerDiv = {style: {}};
        delete map.applyTransform.transform;
        delete map.applyTransform.template;
        var origGetStyle = OpenLayers.Element.getStyle;
        OpenLayers.Element.getStyle = function() { return 'foo'; }
        map.applyTransform(1, 2, 3);
        OpenLayers.Element.getStyle = origGetStyle;
        t.eq(map.layerContainerDiv.style.transform, 'translate3d(1px,2px,0) scale3d(3,3,1)', '3d transform and scale used when available');
        
        delete map.applyTransform.transform;
        delete map.applyTransform.template;
        var origIndexOf = String.prototype.indexOf;
        String.prototype.indexOf = function() { return -1; };
        map.layerContainerOriginPx = {x: -3, y: 2};
        map.applyTransform(1, 2, 3);
        String.prototype.indexOf = origIndexOf;
        t.eq(map.layerContainerDiv.style.transform, 'translate(4px,0px) scale(3,3)', '2d translate and scale correct');
        t.eq(map.layerContainerDiv.style.left, '-3px', 'container origin x set as style.left');
        t.eq(map.layerContainerDiv.style.top, '2px', 'container origin y set as style.top');
        map.applyTransform(1, 2);
        t.ok(!map.layerContainerDiv.style.transform, 'no transform set when no transform needed');
        t.eq(map.layerContainerDiv.style.left, '1px', 'style.left correct when no transform needed');
        t.eq(map.layerContainerDiv.style.top, '2px', 'style.top correct when no transform needed');
        
        map.applyTransform.transform = null;
        map.applyTransform(4, 5, 6);
        t.eq(map.layerContainerDiv.style.left, '4px', 'style.left set when transform not available')
        t.eq(map.layerContainerDiv.style.top, '5px', 'style.top set when transform not available')
        t.ok(!map.layerContainerDiv.style.transform, 'no transform set, because not supported');

        map.destroy();
        delete map.applyTransform.transform;
        delete map.applyTransform.template;
        OpenLayers.Util.vendorPrefix.style = origStylePrefix;
    }

    function test_options(t) {
        t.plan(2);

        var map = new OpenLayers.Map('map');
        t.eq(map.options, {}, 'map.options is empty with no options');
        map.destroy();

        var options = {
            resolutions: [1,2,3,5],
            projection: "EPSG:4326",
            units: 'm'
        };
        var map = new OpenLayers.Map('map', options);
        t.eq(map.options, options, 'map.options is a copy of the constructor option');
        map.destroy();
    }

    function test_adjustZoom(t) {
        t.plan(5);
        var map = new OpenLayers.Map({
            div: 'map',
            layers: [
                new OpenLayers.Layer('name', {
                    isBaseLayer: true,
                    wrapDateLine: true
                })
            ]
        });
        map.zoomToMaxExtent();
        t.ok(map.getResolution() <= map.getMaxExtent().getWidth() / map.getSize().w, "wrapDateLine map not wider than world");
        
        t.eq(map.adjustZoom(9), 9, "valid zoom maintained");
        t.eq(map.adjustZoom(1), 2, "zoom adjusted to not exceed world width");
        
        map.fractionalZoom = true;
        t.eq(map.adjustZoom(1).toPrecision(3), "1.29", "zoom adjusted to match world width");

        map.moveTo([16, 48], 0);
        t.eq(map.getCenter().toShortString(), "0, 0", "no panning when moveTo is called with invalid zoom");
    }

    function test_correctCenterAtZoomLevel0(t) {
        t.plan(1);
        var map = new OpenLayers.Map({
            div: 'map',
            maxExtent: new OpenLayers.Bounds(-30, 48.00, 3.50, 64.00),
            restrictedExtent: new OpenLayers.Bounds(-30, 48.00, 3.50, 64.00),
            projection: "EPSG:4258",
            units: "degrees",
            layers: [
                new OpenLayers.Layer('name', {
                    isBaseLayer: true
                })
            ]
        });
        map.setCenter(new OpenLayers.LonLat(-1.3, 50.8), 4);
        map.moveTo(null, 0);
        var center  = map.getCenter();
        t.ok(center.equals(new OpenLayers.LonLat(-13.25, 56)), "Center is correct and not equal to maxExtent's center");
    }
    
    function test_getZoomTargetCenter(t) {
        t.plan(1);
        var map = new OpenLayers.Map({
            div: 'map',
            layers: [
                new OpenLayers.Layer('', {isBaseLayer: true})
            ],
            center: [0, 0],
            zoom: 1
        });
        
        var ll = map.getZoomTargetCenter({x: 44, y: 22}, map.getMaxResolution());

        t.eq(ll.toShortString(), "180, -90", "getZoomTargetCenter works.");
        
        map.destroy();
    }

    function test_autoUpdateSize(t) {
        t.plan(1);
        OpenLayers.Event.unloadCache();
        var resizeListener = false;
        var map = new OpenLayers.Map({
            autoUpdateSize: false,
            div: 'map',
            layers: [
                new OpenLayers.Layer('name', {
                    isBaseLayer: true,
                    wrapDateLine: true
                })
            ]
        });
        map.setCenter(new OpenLayers.LonLat(-1.3, 50.8), 4);
        for (var key in OpenLayers.Event.observers) {
            var obj = OpenLayers.Event.observers[key];
            for (var i=0, ii=obj.length; i<ii; ++i) {
                var listener = obj[i];
                if (listener.name === 'resize' && listener.element === window) {
                    resizeListener = true;
                }
            }
        }
        t.eq(resizeListener, map.autoUpdateSize, "resize listener not registered when autoUpdateSize is false");
        map.destroy();
    }

    function test_tileManager(t) {
        t.plan(3);
        var map = new OpenLayers.Map('map');
        t.ok(map.tileManager instanceof OpenLayers.TileManager, "Default tileManager created");
        map.destroy();
        map = new OpenLayers.Map('map', {tileManager: null});
        t.ok(map.tileManager === null, "No tileManager created");
        map.destroy();
        var options = {cacheSize: 512};
        map = new OpenLayers.Map('map', {tileManager: options});
        t.eq(map.tileManager.cacheSize, 512, "cacheSize taken from options");
        map.destroy();
    }

  </script>
</head>
<body>
    <div id="map" style="width: 600px; height: 300px;"/>
    <div style="display: none;"><div id="invisimap"></div></div>
</body>
</html>