source: trunk/openlayers/tests/Layer/Google/v3.html

Last change on this file was 11162, checked in by pgiraud, 5 years ago

Adds the possibility to use a built version of OpenLayers for the tests, users simply have to add '?mode=build' in the run-tests.html url

File size: 14.6 KB
Line 
1<html>
2<head>
3    <script src="http://maps.google.com/maps/api/js?sensor=false"></script>
4    <script src="../../OLLoader.js"></script>
5    <script type="text/javascript">
6
7    var layer; 
8                   
9    function test_Layer_Google_constructor (t) {
10        t.plan( 5 );
11       
12        var map = new OpenLayers.Map('map');
13        var layer = new OpenLayers.Layer.Google('Goog Layer');
14        map.addLayer(layer);
15       
16       
17        t.ok( layer instanceof OpenLayers.Layer.Google, "new OpenLayers.Layer.Google returns object" );
18        t.eq( layer.CLASS_NAME, "OpenLayers.Layer.Google", "CLASS_NAME variable set correctly");
19   
20        t.eq( layer.name, "Goog Layer", "layer.name is correct" );
21   
22        t.ok ( layer.mapObject != null, "GMap Object correctly loaded");
23       
24        t.eq(layer.version, "3", "API version 3 detected.");
25    }
26   
27    function test_clone(t) {
28        t.plan(2);
29        var layer, clone;
30       
31        // test default layer
32        layer = new OpenLayers.Layer.Google();
33        clone = layer.clone();
34        t.ok(clone instanceof OpenLayers.Layer.Google, "[default] good instance");
35       
36        layer.destroy();
37        clone.destroy();
38       
39        // test with alt type
40        layer = new OpenLayers.Layer.Google(null, {type: google.maps.MapTypeId.SATELLITE});
41        clone = layer.clone();
42        t.ok(clone.type === google.maps.MapTypeId.SATELLITE, "[sat] correct type");
43       
44        layer.destroy();
45        clone.destroy();   
46    }
47   
48    function test_Layer_Google_isBaseLayer (t) {
49        t.plan(1);
50       
51        var layer = new OpenLayers.Layer.Google('Goog Layer');
52   
53        t.ok(layer.isBaseLayer, "a default load of google layer responds as a base layer");
54    }   
55   
56    function test_Layer_Google_Translation_lonlat (t) {
57        t.plan( 4 );
58       
59        var map = new OpenLayers.Map('map');
60        var layer = new OpenLayers.Layer.Google('Goog Layer');
61        map.addLayer(layer);
62   
63    // these two lines specify an appropriate translation.
64    //  the code afterwards works by itself to test that translation
65    //  works correctly both ways.
66       var gLatLng = new google.maps.LatLng(50,100);
67       // v3 uses sphericalMercator by default
68       var correspondingOLLonLat = new OpenLayers.LonLat(100,50).transform(
69           new OpenLayers.Projection("EPSG:4326"),
70           map.getProjectionObject()
71       );
72   
73   
74       olLonLat = layer.getOLLonLatFromMapObjectLonLat(gLatLng);
75       t.ok(olLonLat.equals(correspondingOLLonLat), "Translation from GLatLng to OpenLayers.LonLat works");
76   
77       var transGLatLng = layer.getMapObjectLonLatFromOLLonLat(olLonLat);
78       t.ok( transGLatLng.equals(gLatLng), "Translation from OpenLayers.LonLat to GLatLng works");
79   
80       t.ok( layer.getMapObjectLonLatFromOLLonLat(null) == null, "getGLatLngFromOLLonLat(null) returns null");
81       t.ok( layer.getOLLonLatFromMapObjectLonLat(null) == null, "getOLLonLatFromGLatLng(null) returns null");
82    }
83   
84    function test_Layer_Google_Translation_pixel (t) {
85        t.plan( 4 );
86       
87        var map = new OpenLayers.Map('map');
88        var layer = new OpenLayers.Layer.Google('Goog Layer');
89        map.addLayer(layer);
90   
91     // these two lines specify an appropriate translation.
92     //  the code afterwards works by itself to test that translation
93     //  works correctly both ways.
94        var gPoint = new google.maps.Point(50,100);
95        var correspondingOLPixel = new OpenLayers.Pixel(50, 100);
96   
97   
98        olPixel = layer.getOLPixelFromMapObjectPixel(gPoint);
99        t.ok( olPixel.equals(correspondingOLPixel), "Translation from GPoint to OpenLayers.Pixel works");
100   
101        var transGPoint = layer.getMapObjectPixelFromOLPixel(olPixel);
102        t.ok( transGPoint.equals(gPoint), "Translation from OpenLayers.Pixel to GPoint works");
103   
104        t.ok( layer.getMapObjectPixelFromOLPixel(null) == null, "getGPointFromOLPixel(null) returns null");
105        t.ok( layer.getOLPixelFromMapObjectPixel(null) == null, "getOLPixelFromGPoint(null) returns null");
106    }
107   
108    function test_Layer_destroy (t) {
109        t.plan( 5 );   
110   
111        var map = new OpenLayers.Map('map');
112       
113        layer = new OpenLayers.Layer.Google('Test Layer');
114        map.addLayer(layer);
115   
116        layer.destroy();
117   
118        t.eq( layer.name, null, "layer.name is null after destroy" );
119        t.eq( layer.div, null, "layer.div is null after destroy" );
120        t.eq( layer.map, null, "layer.map is null after destroy" );
121        t.eq( layer.options, null, "layer.options is null after destroy" );
122        t.eq( layer.gmap, null, "layer.gmap is null after destroy" );
123    }
124   
125    function test_Layer_Goole_forwardMercator(t){
126        t.plan(2);
127        //Just test that the fowardMercator function still exists.
128        var layer = new OpenLayers.Layer.Google('Test Layer', {'sphericalMercator': true});
129        layer.forwardMercator = function(evt) {
130            t.ok(true,
131                 "GoogleMercator.forwardMercator was called and executed." );
132            return;
133        }
134        layer.forwardMercator();
135        //Now test the fowardMercator returns the expected LonLat object
136        var layer = new OpenLayers.Layer.Google('Test Layer', {'sphericalMercator': true});
137        var lonlat2 = new OpenLayers.LonLat(Math.random(),Math.random());
138        var result = layer.forwardMercator(lonlat2.lon, lonlat2.lat);
139        t.ok(result instanceof OpenLayers.LonLat, "OpenLayers.Google.fowardMercator returns LonLat object" );
140    }
141   
142    function test_Layer_Google_overlay(t) {
143        // Test for #849.
144        t.plan(1);
145        var map = new OpenLayers.Map( 'map' , 
146        { controls: [] , 'numZoomLevels':20});
147   
148        var satellite = new OpenLayers.Layer.Google( "Google Satellite" , {type: google.maps.MapTypeId.SATELLITE, 'maxZoomLevel':18} );
149        var layer = new OpenLayers.Layer.WMS.Untiled( "OpenLayers WMS", 
150                "http://labs.metacarta.com/wms/vmap0", {layers: 'basic', 'transparent':true}, 
151                  {isBaseLayer: false} );
152   
153        map.addLayers([satellite, layer]);
154        map.setCenter(new OpenLayers.LonLat(10.205188,48.857593), 5);
155        map.zoomIn();
156        var size = map.getSize();
157        var px = new OpenLayers.Pixel(size.w, size.h);
158        var br = map.getLonLatFromPixel(px);
159        t.ok(layer.grid[0][0].bounds.containsLonLat(br), "Bottom right pixel is covered by untiled WMS layer");
160    }   
161    function test_Layer_Google_isBaseLayer (t) {
162        t.plan(3);
163        var map = new OpenLayers.Map( 'map' , 
164        { controls: [] , 'numZoomLevels':20});
165   
166        var satellite = new OpenLayers.Layer.Google( "Google Satellite" , {type: google.maps.MapTypeId.SATELLITE, 'maxZoomLevel':18} );
167        map.addLayers([satellite]);
168        map.zoomToMaxExtent();
169       
170        t.eq(satellite.div.style.display, "", "Satellite layer is visible.");
171        satellite.setVisibility(false);
172        t.eq(satellite.div.style.display, "none", "Satellite layer is not visible.");
173        satellite.setVisibility(true);
174        t.eq(satellite.div.style.display, "block", "Satellite layer is visible.");
175    }   
176   
177    function test_Layer_Google_setGMapVisibility(t) {
178        t.plan(3);
179   
180        var map = new OpenLayers.Map('map');
181        var gmap = new OpenLayers.Layer.Google("Google Streets");
182        var dummy = new OpenLayers.Layer("Dummy", {isBaseLayer: true});
183        map.addLayers([dummy, gmap]);
184        map.zoomToMaxExtent();
185   
186        // In v3, the terms of use and powered by elements are not available
187        // until the layer loads.  This can occur before the layer is visible,
188        // but we don't try to access these elements until after the layer is
189        // made visible for the first time. 
190        var cache = OpenLayers.Layer.Google.cache[map.id];
191        t.ok(!cache.termsOfUse, "termsOfUse is not yet cached");
192        t.ok(!cache.poweredBy, "poweredBy is not yet cached");
193
194        var called = 0;
195        var original = gmap.repositionMapElements;
196        gmap.repositionMapElements = function() {
197            ++called;
198            original.apply(gmap, arguments);
199        }
200
201        map.setBaseLayer(gmap);
202        t.delay_call(4, function() {
203            t.ok(called > 0, "repositionMapElements called");
204            map.destroy();
205        });           
206    }
207
208    function test_Layer_Google_setGMapVisibility_allOverlays(t) {
209         t.plan(3);
210     
211         var map = new OpenLayers.Map('map', {allOverlays: true});
212         var gmap = new OpenLayers.Layer.Google("Google Streets", {visibility: false});
213         var dummy = new OpenLayers.Layer("Dummy");
214         map.addLayers([gmap, dummy]);
215         map.zoomToMaxExtent();
216         
217         // In v3, the terms of use and powered by elements are not available
218         // until the layer loads.  This can occur before the layer is visible,
219         // but we don't try to access these elements until after the layer is
220         // made visible for the first time.
221         var cache = OpenLayers.Layer.Google.cache[map.id];
222         t.ok(!cache.termsOfUse, "termsOfUse is not yet cached");
223         t.ok(!cache.poweredBy, "poweredBy is not yet cached");
224     
225         var called = 0;
226         var original = gmap.repositionMapElements;
227         gmap.repositionMapElements = function() {
228             ++called;
229             original.apply(gmap, arguments);
230         }   
231
232         gmap.setVisibility(true);
233         t.delay_call(2, function() {
234             t.ok(called > 0, "repositionMapElements called");
235             map.destroy();
236         });           
237     }
238
239     function test_allOverlays_invisible(t) {
240
241         t.plan(1);
242
243         var map = new OpenLayers.Map('map', {allOverlays: true});
244
245         var osm = new OpenLayers.Layer.OSM();
246         var gmap = new OpenLayers.Layer.Google("Google Streets", {visibility: false});
247
248         // keep track of last argument to setGMapVisibility
249         var visible;
250         var original = gmap.setGMapVisibility;
251         gmap.setGMapVisibility = function(vis) {
252             visible = vis;
253             original.apply(gmap, arguments);
254         }
255
256         map.addLayers([osm, gmap]);
257         map.zoomToMaxExtent();
258
259         t.ok(visible === false, "setGMapVisibility last called with false");
260
261         map.destroy();
262
263     }
264     
265     function test_allOverlays_pan(t) {
266
267         t.plan(8);
268
269         var origPrecision = OpenLayers.Util.DEFAULT_PRECISION;
270         // GMaps v3 seems to use a default precision of 13, which is lower
271         // than what we use in OpenLayers.
272         // See http://trac.osgeo.org/openlayers/ticket/3059
273         OpenLayers.Util.DEFAULT_PRECISION = 13;
274
275         var map = new OpenLayers.Map('map', {allOverlays: true});
276
277         var gmap = new OpenLayers.Layer.Google("Google Streets");
278         var osm = new OpenLayers.Layer.OSM();
279         map.addLayers([gmap, osm]);
280
281         var origin = new OpenLayers.LonLat(1000000, 6000000);
282         map.setCenter(origin, 4);
283         var resolution = map.getResolution();
284         
285         var dx, dy, center, expected;
286
287         // confirm that panning works with Google visible
288         dx = 100, dy = -100;
289         map.pan(dx, dy, {animate: false});
290         center = map.getCenter();
291         expected = new OpenLayers.LonLat(
292             origin.lon + (resolution * dx),
293             origin.lat - (resolution * dy)
294         );
295         t.eq(center.lon, expected.lon, "x panning with Google visible " + dx + ", " + dy);
296         t.eq(center.lat, expected.lat, "y panning with Google visible " + dx + ", " + dy);
297         map.pan(-dx, -dy, {animate: false});
298         center = map.getCenter();
299         t.eq(center.lon, origin.lon, "x panning with Google visible " + (-dx) + ", " + (-dy));
300         t.eq(center.lat, origin.lat, "y panning with Google visible " + (-dx) + ", " + (-dy));
301
302         // confirm that panning works with Google invisible
303         gmap.setVisibility(false);
304         dx = 100, dy = -100;
305         map.pan(dx, dy, {animate: false});
306         center = map.getCenter();
307         expected = new OpenLayers.LonLat(
308             origin.lon + (resolution * dx),
309             origin.lat - (resolution * dy)
310         );
311         t.eq(center.lon, expected.lon, "x panning with Google invisible " + dx + ", " + dy);
312         t.eq(center.lat, expected.lat, "y panning with Google invisible " + dx + ", " + dy);
313         map.pan(-dx, -dy, {animate: false});
314         center = map.getCenter();
315         t.eq(center.lon, origin.lon, "x panning with Google invisible " + (-dx) + ", " + (-dy));
316         t.eq(center.lat, origin.lat, "y panning with Google invisible " + (-dx) + ", " + (-dy));
317
318         map.destroy();
319         OpenLayers.Util.DEFAULT_PRECISION = origPrecision;
320     }
321     
322     function test_wrapDateLine(t) {
323         t.plan(2);
324
325         var origPrecision = OpenLayers.Util.DEFAULT_PRECISION;
326         // GMaps v3 seems to use a default precision of 13, which is lower
327         // than what we use in OpenLayers.
328         // See http://trac.osgeo.org/openlayers/ticket/3059
329         OpenLayers.Util.DEFAULT_PRECISION = 13;
330
331         var map = new OpenLayers.Map("map");
332
333         var gmap = new OpenLayers.Layer.Google("Google Streets");
334         map.addLayer(gmap);
335         map.setCenter(new OpenLayers.LonLat(0, 0), 1);
336         
337         var center;
338         
339         // pan to the edge of the world
340         map.pan(256, 0, {animate: false});
341         center = map.getCenter();
342         t.eq(center.lon, 20037508.34, "edge of the world");
343         // pan off the edge of the world
344         map.pan(100, 0, {animate: false});
345         center = map.getCenter();
346         var expect = OpenLayers.Util.toFloat(100 * map.getResolution() - 20037508.34);
347         t.eq(center.lon, expect, "magically back in the western hemisphere");
348         
349         map.destroy();
350         OpenLayers.Util.DEFAULT_PRECISION = origPrecision;         
351     }
352
353     function test_respectDateLine(t) {
354         t.plan(2);
355
356         var map = new OpenLayers.Map("map");
357
358         var gmap = new OpenLayers.Layer.Google("Google Streets", {wrapDateLine: false});
359         map.addLayer(gmap);
360         map.setCenter(new OpenLayers.LonLat(0, 0), 1);
361         
362         var center;
363         
364         // pan to the edge of the world
365         map.pan(256, 0, {animate: false});
366         center = map.getCenter();
367         t.eq(center.lon, 20037508.34, "edge of the world");
368         // pan off the edge of the world
369         map.pan(100, 0, {animate: false});
370         center = map.getCenter();
371         t.eq(center.lon, 20037508.34, "whew, still on the edge");
372         
373         map.destroy();
374         
375     }
376     
377  </script>
378</head>
379<body>
380    <div id="map" style="width:500px; height: 500px"></div>
381</body>
382</html>
Note: See TracBrowser for help on using the repository browser.