← Back to branch summary

~mortenoh/+junk/dhis2-detailed-import-export

« back to all changes in this revision

Viewing changes to gis/dhis-gis-geostat/mfbase/openlayers/tests/Layer.html

  • Committer: larshelge at gmail
  • Date: 2009-03-03 16:46:36 UTC
  • Revision ID: larshelge@gmail.com-20090303164636-2sjlrquo7ib1gf7r
Initial check-in

Show diffs side-by-side

added added

removed removed

Lines of Context:
gis/dhis-gis-geostat/mfbase/openlayers/tests/Layer.html
 
1
<html>
 
2
<head>
 
3
  <script src="../lib/OpenLayers.js"></script>
 
4
  <script type="text/javascript">
 
5
    var layer; 
 
6
 
 
7
    function test_Layer_constructor (t) {
 
8
        t.plan( 15 );
 
9
        
 
10
        var options = { chicken: 151, foo: "bar", projection: "none" };
 
11
        var layer = new OpenLayers.Layer('Test Layer', options);
 
12
        
 
13
        t.ok( layer instanceof OpenLayers.Layer, "new OpenLayers.Layer returns object" );
 
14
        t.eq( layer.CLASS_NAME, "OpenLayers.Layer", "CLASS_NAME variable set correctly");
 
15
 
 
16
        t.eq( layer.name, "Test Layer", "layer.name is correct" );
 
17
        t.ok( layer.id != null, "Layer is given an id");
 
18
        t.ok( layer.projection, "none", "default layer projection correctly set");
 
19
        t.ok( ((layer.chicken == 151) && (layer.foo == "bar")), "layer.options correctly set to Layer Object" );
 
20
        t.ok( ((layer.options["chicken"] == 151) && (layer.options["foo"] == "bar")), "layer.options correctly backed up" );
 
21
 
 
22
        t.ok( typeof layer.div == "object" , "layer.div is created" );
 
23
        t.eq( layer.div.id, layer.id, "layer.div.id is correct" );
 
24
 
 
25
        options.chicken = 552;
 
26
        
 
27
        t.eq( layer.options["chicken"], 151 , "layer.options correctly made fresh copy" );
 
28
        
 
29
        t.eq( layer.isBaseLayer, false, "Default layer is not base layer" );
 
30
 
 
31
        layer = new OpenLayers.Layer('Test Layer');
 
32
        t.ok( layer instanceof OpenLayers.Layer, "new OpenLayers.Layer returns object" );
 
33
        t.eq( layer.name, "Test Layer", "layer.name is correct" );
 
34
        t.ok( layer.projection == null, "default layer projection correctly set");
 
35
        t.ok( layer.options instanceof Object, "layer.options correctly initialized as a non-null Object" );
 
36
    }
 
37
 
 
38
    function test_Layer_clone (t) {
 
39
        t.plan( 8 );
 
40
        
 
41
        var mapone = new OpenLayers.Map('map'); 
 
42
        var options = { chicken: 151, foo: "bar", maxResolution: "auto" };
 
43
        var layer = new OpenLayers.Layer('Test Layer', options);
 
44
        mapone.addLayer(layer);
 
45
 
 
46
        // randomly assigned property
 
47
        layer.chocolate = 5;
 
48
 
 
49
        var clone = layer.clone();
 
50
 
 
51
        t.ok( clone.map == null, "cloned layer has map property set to null")
 
52
 
 
53
        var maptwo = new OpenLayers.Map('map2'); 
 
54
        maptwo.addLayer(clone);
 
55
 
 
56
        t.ok( clone instanceof OpenLayers.Layer, "new OpenLayers.Layer returns object" );
 
57
        t.eq( clone.name, "Test Layer", "default clone.name is correct" );
 
58
        t.ok( ((clone.options["chicken"] == 151) && (clone.options["foo"] == "bar")), "clone.options correctly set" );
 
59
        t.eq(clone.chocolate, 5, "correctly copied randomly assigned property");
 
60
 
 
61
        layer.addOptions({chicken:152});
 
62
        t.eq(clone.options["chicken"], 151, "made a clean copy of options");        
 
63
 
 
64
        t.ok( (layer.maxResolution != clone.maxResolution), "maxresolution of clone reset to new map div");
 
65
        t.ok( (layer.minResolution != clone.minResolution), "minresolution of clone reset to new map div");
 
66
        
 
67
        mapone.destroy();
 
68
        maptwo.destroy();
 
69
    }
 
70
 
 
71
    function test_Layer_setName (t) {
 
72
        
 
73
        t.plan( 1 );
 
74
 
 
75
        layer = new OpenLayers.Layer('Test Layer');
 
76
        layer.setName("chicken");
 
77
        
 
78
        t.eq(layer.name, "chicken", "setName() works")
 
79
        
 
80
    }
 
81
 
 
82
    function test_Layer_addOptions (t) {
 
83
        
 
84
        t.plan( 4 );
 
85
 
 
86
        var options = { chicken: 151, foo: "bar" };
 
87
        var layer = new OpenLayers.Layer('Test Layer', options);
 
88
 
 
89
        layer.addOptions({bark:55, chicken: 171});
 
90
 
 
91
        t.eq(layer.bark, 55, "addOptions() assigns new option correctly to Layer");
 
92
        t.eq(layer.options.bark, 55, "addOptions() adds new option correctly to backup");
 
93
 
 
94
        t.eq(layer.chicken, 171, "addOptions() overwrites option correctly to Layer");
 
95
        t.eq(layer.options.chicken, 171, "addOptions() overwrites option correctly to backup");
 
96
 
 
97
    }
 
98
    
 
99
    function test_Layer_StandardOptionsAccessors (t) {
 
100
 
 
101
        t.plan( 4 );
 
102
 
 
103
        var projection = "chicken";
 
104
        var maxExtent = new OpenLayers.Bounds(50,50,100,100);
 
105
        var maxResolution = 1.5726;
 
106
        var numZoomLevels = 11;
 
107
 
 
108
        var options = { projection: projection, 
 
109
                        maxExtent: maxExtent,
 
110
                        maxResolution: maxResolution,
 
111
                        numZoomLevels: numZoomLevels
 
112
                        };
 
113
 
 
114
        var layer = new OpenLayers.Layer('Test Layer', options);
 
115
 
 
116
        t.eq(layer.projection, projection, "projection set correctly");
 
117
        t.ok(layer.maxExtent.equals(maxExtent), "maxExtent set correctly");
 
118
        t.eq(layer.maxResolution, maxResolution, "maxResolution set correctly");
 
119
        t.eq(layer.numZoomLevels, numZoomLevels, "numZoomLevels set correctly");
 
120
    }
 
121
    
 
122
    function test_eventListeners(t) {
 
123
        t.plan(1);
 
124
        
 
125
        var method = OpenLayers.Events.prototype.on;
 
126
        // test that events.on is called at layer construction
 
127
        var options = {
 
128
            eventListeners: {foo: "bar"}
 
129
        };
 
130
        OpenLayers.Events.prototype.on = function(obj) {
 
131
            t.eq(obj, options.eventListeners, "events.on called with eventListeners");
 
132
        }
 
133
        var layer = new OpenLayers.Layer("test", options);
 
134
        OpenLayers.Events.prototype.on = method;
 
135
        layer.destroy();
 
136
        
 
137
        // if events.on is called again, this will fail due to an extra test
 
138
        // test layer without eventListeners
 
139
        OpenLayers.Events.prototype.on = function(obj) {
 
140
            t.fail("events.on called without eventListeners");
 
141
        }
 
142
        var layer2 = new OpenLayers.Layer("test");
 
143
        OpenLayers.Events.prototype.on = method;
 
144
        layer2.destroy();
 
145
    }
 
146
 
 
147
    function test_Layer_initResolutions(t) {
 
148
        t.plan(15);
 
149
        var map = new OpenLayers.Map("map");
 
150
        var options, layer;
 
151
        
 
152
        // tests for minResolution, maxResolution, and numZoomLevels
 
153
        options = {
 
154
            minResolution: 1.5,
 
155
            maxResolution: 10.5,
 
156
            numZoomLevels: 5,
 
157
            map: map
 
158
        };
 
159
        layer = new OpenLayers.Layer("test", options);
 
160
        layer.initResolutions();
 
161
        t.eq(layer.minResolution.toPrecision(6), (1.5).toPrecision(6),
 
162
             "(with numZoomLevels) layer minResolution preserved");
 
163
        t.eq(layer.maxResolution.toPrecision(6), (10.5).toPrecision(6),
 
164
             "(with numZoomLevels) layer maxResolution preserved");
 
165
        t.eq(layer.numZoomLevels, 5, "(with numZoomLevels) layer numZoomLevels preserved");
 
166
        t.eq(layer.alwaysInRange, false, "Always in range is set to false due to passed options.")        
 
167
 
 
168
        // three tests for minResolution, and maxResolution
 
169
        options = {
 
170
            minResolution: 1.5,
 
171
            maxResolution: 10.5,
 
172
            map: map
 
173
        };
 
174
        layer = new OpenLayers.Layer("test", options);
 
175
        layer.initResolutions();
 
176
        t.eq(layer.minResolution.toPrecision(6), (1.5).toPrecision(6),
 
177
             "(without numZoomLevels) layer minResolution preserved");
 
178
        t.eq(layer.maxResolution.toPrecision(6), (10.5).toPrecision(6),
 
179
             "(without numZoomLevels) layer maxResolution preserved");
 
180
        t.eq(layer.numZoomLevels, 3, "(without numZoomLevels) layer numZoomLevels calculated");
 
181
        
 
182
        // three tests for minScale, maxScale, and numZoomLevels
 
183
        options = {
 
184
            minScale: 105,
 
185
            maxScale: 15,
 
186
            numZoomLevels: 10,
 
187
            map: map
 
188
        };
 
189
        layer = new OpenLayers.Layer("test", options);
 
190
        layer.initResolutions();
 
191
        t.eq(layer.minScale.toPrecision(6), (105).toPrecision(6),
 
192
             "(with numZoomLevels) layer minScale preserved");
 
193
        t.eq(layer.maxScale.toPrecision(6), (15).toPrecision(6),
 
194
             "(with numZoomLevels) layer maxScale preserved");
 
195
        t.eq(layer.numZoomLevels, 10, "(with numZoomLevels) layer numZoomLevels preserved");
 
196
        
 
197
        // three tests for minScale, and maxScale
 
198
        options = {
 
199
            minScale: 1555,
 
200
            maxScale: 155,
 
201
            map: map
 
202
        };
 
203
        layer = new OpenLayers.Layer("test", options);
 
204
        layer.initResolutions();
 
205
        t.eq(layer.minScale.toPrecision(6), (1555).toPrecision(6),
 
206
             "(without numZoomLevels) layer minScale preserved");
 
207
        t.eq(layer.maxScale.toPrecision(6), (155).toPrecision(6),
 
208
             "(without numZoomLevels) layer maxScale preserved");
 
209
        t.eq(layer.numZoomLevels, 4, "(without numZoomLevels) layer numZoomLevels calculated");
 
210
        
 
211
        layer = new OpenLayers.Layer("test", {'projection': 'EPSG:4326', 'map': map});
 
212
        layer.initResolutions();
 
213
        t.eq(layer.alwaysInRange, true, "always in range true if only get projection.");     
 
214
        
 
215
        OpenLayers.Layer.prototype.alwaysInRange = false;
 
216
        layer = new OpenLayers.Layer("test", {'projection': 'EPSG:4326', 'map': map});
 
217
        layer.initResolutions();
 
218
        t.eq(layer.alwaysInRange, false, "always in range true if overridden on prototype.");     
 
219
        OpenLayers.Layer.prototype.alwaysInRange = null;
 
220
 
 
221
        map.destroy();
 
222
        
 
223
        
 
224
    }
 
225
 
 
226
    function test_Layer_visibility(t) {
 
227
 
 
228
        t.plan(7);
 
229
 
 
230
        var layer = new OpenLayers.Layer('Test Layer');
 
231
    
 
232
        t.eq(layer.getVisibility(), true, "default for layer creation is visible");
 
233
        
 
234
        layer.setVisibility(false);
 
235
        t.eq(layer.getVisibility(), false, "setVisibility false works");
 
236
 
 
237
        layer.setVisibility(true);
 
238
        t.eq(layer.getVisibility(), true, "setVisibility true works");
 
239
       
 
240
        // Need a map in order to have moveTo called.
 
241
        // Tests added for #654.
 
242
        var layer = new OpenLayers.Layer.WMS('Test Layer','http://example.com');
 
243
        var m = new OpenLayers.Map('map');
 
244
        m.addLayer(layer);
 
245
        m.zoomToMaxExtent();
 
246
        
 
247
        layermoved = false; 
 
248
        layer.moveTo = function() { layermoved = true; }
 
249
        
 
250
        layer.events.register('visibilitychanged', t, function() {
 
251
            this.ok(true, "Visibility changed calls layer event.");
 
252
        });    
 
253
        
 
254
        layer.setVisibility(false);
 
255
        t.eq(layermoved, false, "Layer didn't move when calling setvis false");
 
256
        
 
257
        layer.setVisibility(true);
 
258
        t.eq(layermoved, true, "Layer moved when calling setvis true.");
 
259
    
 
260
    }
 
261
 
 
262
 
 
263
    function test_Layer_getZoomForResolution(t) {
 
264
 
 
265
        t.plan(12);
 
266
 
 
267
        var layer = new OpenLayers.Layer('Test Layer');
 
268
        layer.map = {};
 
269
        
 
270
        //make some dummy resolutions
 
271
        layer.resolutions = [128, 64, 32, 16, 8, 4, 2];
 
272
        
 
273
        t.eq(layer.getZoomForResolution(200), 0, "zoom all the way out");
 
274
        t.eq(layer.getZoomForResolution(25), 2, "zoom in middle");
 
275
        t.eq(layer.getZoomForResolution(3), 5, "zoom allmost all the way in");
 
276
        t.eq(layer.getZoomForResolution(1), 6, "zoom  all the way in");
 
277
 
 
278
        t.eq(layer.getZoomForResolution(65), 0, "smallest containing res");
 
279
        t.eq(layer.getZoomForResolution(63), 1, "smallest containing res");
 
280
 
 
281
        t.eq(layer.getZoomForResolution(65, true), 1, "closest res");
 
282
        t.eq(layer.getZoomForResolution(63, true), 1, "closest res");
 
283
        
 
284
        layer.map.fractionalZoom = true;
 
285
        t.eq(layer.getZoomForResolution(64), 1,
 
286
             "(fractionalZoom) correct zoom for res in array");
 
287
        t.eq(layer.getZoomForResolution(48).toPrecision(6), (1.5).toPrecision(6),
 
288
             "(fractionalZoom) linear scaling for res between entries");
 
289
        t.eq(layer.getZoomForResolution(200).toPrecision(6), (0).toPrecision(6),
 
290
             "(fractionalZoom) doesn't return zoom below zero");
 
291
        t.eq(layer.getZoomForResolution(1).toPrecision(6), (layer.resolutions.length - 1).toPrecision(6),
 
292
             "(fractionalZoom) doesn't return zoom above highest index");
 
293
 
 
294
    }
 
295
    
 
296
    function test_Layer_redraw(t) {
 
297
        t.plan(8)
 
298
 
 
299
        var name = 'Test Layer';
 
300
        var url = "http://octo.metacarta.com/cgi-bin/mapserv";
 
301
        var params = { map: '/mapdata/vmap_wms.map', 
 
302
                       layers: 'basic', 
 
303
                       format: 'image/jpeg'};
 
304
 
 
305
        var layer = new OpenLayers.Layer.WMS(name, url, params);
 
306
        
 
307
        t.ok(!layer.redraw(),
 
308
             "redraw on an orphan layer returns false");
 
309
        
 
310
        var map = new OpenLayers.Map('map');
 
311
        map.addLayer(layer);
 
312
 
 
313
        t.ok(!layer.redraw(),
 
314
             "redraw returns false if map does not yet have a center");
 
315
        map.zoomToMaxExtent();
 
316
        
 
317
        t.ok(layer.redraw(),
 
318
             "redraw returns true after map has a center");
 
319
        
 
320
        layer.setVisibility(false);
 
321
        t.ok(!layer.redraw(),
 
322
             "redraw returns false if a layer is not visible");
 
323
        
 
324
        layer.setVisibility(true);
 
325
        t.ok(layer.redraw(),
 
326
                "redraw returns true even if extent has not changed");
 
327
        
 
328
        layer.moveTo = function(bounds, zoomChanged, dragging) {
 
329
            var extent = layer.map.getExtent();
 
330
            t.ok(bounds.equals(extent),
 
331
                 "redraw calls moveTo with the map extent");
 
332
            t.ok(zoomChanged,
 
333
                 "redraw calls moveTo with zoomChanged true");
 
334
            t.ok(!dragging,
 
335
                 "redraw calls moveTo with dragging false");
 
336
        }
 
337
        layer.redraw();
 
338
        
 
339
    }
 
340
      
 
341
    function test_layer_setIsBaseLayer(t) {
 
342
        t.plan(2);
 
343
        var map = new OpenLayers.Map('map');
 
344
        layer = new OpenLayers.Layer();
 
345
 
 
346
        map.events.register("changebaselayer", t, function() {
 
347
          this.ok(true, "setIsBaseLayer() trig changebaselayer event.")
 
348
        });
 
349
 
 
350
        map.addLayer(layer);
 
351
        layer.setIsBaseLayer(true);
 
352
        t.ok(layer.isBaseLayer, "setIsBaseLayer() change isBaseLayer property.");
 
353
    }
 
354
      
 
355
    function test_layer_setTileSize(t) {
 
356
        t.plan(6);
 
357
 
 
358
        layer = new OpenLayers.Layer();
 
359
        
 
360
        g_MapTileSize = new OpenLayers.Size(25,67);        
 
361
        layer.map = {
 
362
            getTileSize: function() {
 
363
                return g_MapTileSize;
 
364
            }
 
365
        };
 
366
 
 
367
        var layerTileSize = new OpenLayers.Size(1,1);
 
368
 
 
369
    //TILE SIZE
 
370
        layer.tileSize = layerTileSize;
 
371
      
 
372
      //parameter
 
373
        var size = new OpenLayers.Size(2,2);
 
374
        layer.setTileSize(size);
 
375
        t.ok(layer.tileSize.equals(size), "size paramater set correctly to layer's tile size");
 
376
        t.ok(layer.imageOffset == null, "imageOffset and imageSize null when no gutters")
 
377
      
 
378
      //set on layer
 
379
        layer.tileSize = layerTileSize;
 
380
        layer.setTileSize();
 
381
        t.ok(layer.tileSize.equals(layerTileSize), "layer's tileSize property preserved if no parameter sent in");
 
382
      
 
383
      //take it from map
 
384
        layer.tileSize = null;
 
385
        layer.setTileSize();
 
386
        t.ok(layer.tileSize.equals(g_MapTileSize), "layer's tileSize property is null and so correctly taken from the map");
 
387
        
 
388
        
 
389
 
 
390
    //GUTTERS
 
391
        layer.gutter = 15;
 
392
        size = new OpenLayers.Size(10,100);
 
393
        layer.setTileSize(size);
 
394
 
 
395
        var desiredImageOffset = new OpenLayers.Pixel(-15, -15); 
 
396
        var desiredImageSize = new OpenLayers.Size(40, 130); 
 
397
 
 
398
        t.ok(layer.imageOffset.equals(desiredImageOffset), "image offset correctly calculated");
 
399
        t.ok(layer.imageSize.equals(desiredImageSize), "image size correctly calculated");
 
400
    }
 
401
    
 
402
    function test_Layer_getResolution(t) {
 
403
        t.plan(1);
 
404
        var layer = new OpenLayers.Layer("test");
 
405
        layer.map = {
 
406
            getZoom: function() {return "foo";}
 
407
        };
 
408
        layer.getResolutionForZoom = function(zoom) {
 
409
            t.eq(zoom, "foo", "getResolution calls getResolutionForZoom");
 
410
        }
 
411
        layer.getResolution();
 
412
        layer.map = null;
 
413
        layer.destroy();
 
414
    }
 
415
    
 
416
    function test_Layer_getResolutionForZoom(t) {
 
417
        t.plan(5);
 
418
        var layer = new OpenLayers.Layer("test");
 
419
        layer.map = {fractionalZoom: false};
 
420
        layer.resolutions = ["zero", "one", "two"];
 
421
        t.eq(layer.getResolutionForZoom(0), "zero",
 
422
             "(fractionalZoom false) returns resolution for given index");
 
423
        t.eq(layer.getResolutionForZoom(0.9), "one",
 
424
             "(fractionalZoom false) returns resolution for float index");
 
425
        
 
426
        layer.resolutions = [2, 4, 6, 8];
 
427
        layer.map.fractionalZoom = true;
 
428
        t.eq(layer.getResolutionForZoom(1).toPrecision(6), (4).toPrecision(6),
 
429
             "(fractionalZoom true) returns resolution for integer zoom");
 
430
        t.eq(layer.getResolutionForZoom(1.5).toPrecision(6), (5).toPrecision(6),
 
431
             "(fractionalZoom true) returns resolution for float zoom");             
 
432
        t.eq(layer.getResolutionForZoom(3.5).toPrecision(6), (8).toPrecision(6),
 
433
             "(fractionalZoom true) returns resolution for zoom beyond res length - 1");
 
434
        
 
435
    }
 
436
 
 
437
 
 
438
 
 
439
/******
 
440
 * 
 
441
 * 
 
442
 * HERE IS WHERE SOME TESTS SHOULD BE PUT TO CHECK ON THE LONLAT-PX TRANSLATION
 
443
 * FUNCTIONS AND RESOLUTION AND GETEXTENT GETZOOMLEVEL, ETC
 
444
 * 
 
445
 * 
 
446
 */
 
447
 
 
448
 
 
449
    function test_Layer_destroy (t) {
 
450
        t.plan( 5 );    
 
451
 
 
452
        var map = new OpenLayers.Map('map');
 
453
        
 
454
        layer = new OpenLayers.Layer('Test Layer');
 
455
 
 
456
        map.addLayer(layer);
 
457
 
 
458
        layer.destroy();
 
459
 
 
460
        t.eq( layer.name, null, "layer.name is null after destroy" );
 
461
        t.eq( layer.div, null, "layer.div is null after destroy" );
 
462
        t.eq( layer.map, null, "layer.map is null after destroy" );
 
463
        t.eq( layer.options, null, "layer.options is null after destroy" );
 
464
 
 
465
        t.eq(map.layers.length, 0, "layer removed from map");
 
466
        
 
467
        map.destroy();
 
468
 
 
469
    }
 
470
 
 
471
  </script>
 
472
</head>
 
473
<body>
 
474
  <div id="map" style="width:500px;height:500px"></div>
 
475
  <div id="map2" style="width:100px;height:100px"></div>
 
476
</body>
 
477
</html>