OpenLayers OpenLayers

Ticket #1128: renderers_tests.2.patch

File renderers_tests.2.patch, 30.1 kB (added by pgiraud, 1 year ago)

tests for Renderer, Elements (almost complete), SVG

  • tests/Renderer/test_SVG.html

    old new  
     1<html> 
     2<head> 
     3<script src="../../lib/OpenLayers.js"></script> 
     4  <script type="text/javascript"> 
     5 
     6    var geometry = null, node = null; 
     7     
     8    function test_SVG_constructor(t) { 
     9        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     10            t.plan(0); 
     11            return; 
     12        } 
     13         
     14        t.plan(1); 
     15        var r = new OpenLayers.Renderer.SVG(document.body); 
     16        t.ok(r instanceof OpenLayers.Renderer.SVG, "new OpenLayers.Renderer.SVG returns SVG object" ); 
     17    } 
     18     
     19    function test_SVG_destroy(t) { 
     20        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     21            t.plan(0); 
     22            return; 
     23        } 
     24         
     25        t.plan(5); 
     26         
     27        var g_Clear = false, g_Destroy = false; 
     28         
     29        OpenLayers.Renderer.SVG.prototype._clear =  
     30            OpenLayers.Renderer.SVG.prototype.clear; 
     31             
     32        OpenLayers.Renderer.SVG.prototype.clear = function() { 
     33            g_Clear = true; 
     34        } 
     35         
     36        OpenLayers.Renderer.prototype._destroy =  
     37            OpenLayers.Renderer.prototype.destroy; 
     38             
     39        OpenLayers.Renderer.prototype.destroy = function() { 
     40            g_Destroy = true; 
     41        } 
     42         
     43        var r = new OpenLayers.Renderer.SVG(document.body); 
     44        r.destroy(); 
     45         
     46        t.eq(g_Clear, true, "OpenLayers.Renderer.Elements.clear() called"); 
     47        t.eq(r.rendererRoot, null, "rendererRoot nullified"); 
     48        t.eq(r.root, null, "root nullified"); 
     49        t.eq(r.xmlns, null, "xmlns nullified"); 
     50        t.eq(g_Destroy, true, "OpenLayers.Renderer.destroy() called"); 
     51         
     52        OpenLayers.Renderer.SVG.prototype.clear =  
     53            OpenLayers.Renderer.SVG.prototype._clear; 
     54        OpenLayers.Renderer.prototype.destroy =  
     55            OpenLayers.Renderer.prototype._destroy; 
     56    } 
     57     
     58    function test_SVG_clear(t) { 
     59        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     60            t.plan(0); 
     61            return; 
     62        } 
     63         
     64        t.plan(1); 
     65         
     66        var r = new OpenLayers.Renderer.SVG(document.body); 
     67        r.clear(); 
     68         
     69        t.eq(r.root.childNodes.length, 0, "root is cleared"); 
     70    } 
     71     
     72    function test_SVG_setextent(t) { 
     73        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     74            t.plan(0); 
     75            return; 
     76        } 
     77         
     78        t.plan(5); 
     79         
     80        OpenLayers.Renderer.Elements.prototype._setExtent = 
     81            OpenLayers.Renderer.Elements.prototype.setExtent; 
     82         
     83        var g_SetExtent = false; 
     84        OpenLayers.Renderer.Elements.prototype.setExtent = function() { 
     85            g_SetExtent = true; 
     86        } 
     87                 
     88        var r = new OpenLayers.Renderer.SVG(document.body); 
     89        r.map = { 
     90            getResolution: function() { 
     91                return 0.5; 
     92            } 
     93        } 
     94         
     95        var extent = new OpenLayers.Bounds(1,2,3,4); 
     96        r.setExtent(extent); 
     97         
     98        t.eq(g_SetExtent, true, "Elements.setExtent() called"); 
     99         
     100        t.eq(r.left, -2, "left is correct"); 
     101        t.eq(r.top, 8, "top is correct"); 
     102         
     103        t.eq(r.rendererRoot.getAttributeNS(null, "viewBox"), "0 0 4 4", "rendererRoot viewBox is correct"); 
     104         
     105        var extent = new OpenLayers.Bounds(4,3,2,1); 
     106        r.setExtent(extent); 
     107        t.eq(r.rendererRoot.getAttributeNS(null, "viewBox"), "6 6 -4 -4", "rendererRoot viewBox is correct after a new setExtent"); 
     108 
     109        OpenLayers.Renderer.Elements.prototype.setExtent = 
     110            OpenLayers.Renderer.Elements.prototype._setExtent; 
     111    } 
     112     
     113    function test_SVG_setsize(t) { 
     114        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     115            t.plan(0); 
     116            return; 
     117        } 
     118         
     119        t.plan(2); 
     120                 
     121        var r = new OpenLayers.Renderer.SVG(document.body); 
     122         
     123        var size = new OpenLayers.Size(1,2); 
     124        r.setSize(size); 
     125        t.eq(r.rendererRoot.getAttributeNS(null, "width"), size.w.toString(), "width is correct"); 
     126        t.eq(r.rendererRoot.getAttributeNS(null, "height"), size.h.toString(), "height is correct"); 
     127    } 
     128     
     129    function test_SVG_drawGeometry(t) { 
     130        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     131            t.plan(0); 
     132            return; 
     133        } 
     134     
     135        t.plan(4); 
     136 
     137        var r = new OpenLayers.Renderer.SVG(document.body); 
     138 
     139        r.drawGeometryNode = function(n, g) { 
     140            node = n; 
     141            t.plan(0); 
     142            return; 
     143        } 
     144        r.getNodeType = function(geometry) { 
     145            return "div"; 
     146        } 
     147        geometry = { 
     148            id: 'foo', 
     149            CLASS_NAME: 'bar' 
     150        }; 
     151        var style = true; 
     152        var featureId = 'dude'; 
     153        r.drawGeometry(geometry, style, featureId); 
     154        t.ok(node.parentNode == r.root, "node is correctly appended to root"); 
     155        t.eq(node._featureId, 'dude', "_featureId is correct"); 
     156        t.ok(node._style, "_style is correct"); 
     157        t.eq(node._geometryClass, 'bar', "_geometryClass is correct"); 
     158    } 
     159     
     160    function test_SVG_drawGeometry_2(t) { 
     161        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     162            t.plan(0); 
     163            return; 
     164        } 
     165     
     166        t.plan(9); 
     167 
     168        var r = new OpenLayers.Renderer.SVG(document.body); 
     169         
     170        // point 
     171        var properDraw = false; 
     172        r.drawPoint = function(node, geometry) { 
     173            properDraw = true; 
     174            node = node; 
     175            return {}; 
     176        } 
     177        geometry = {CLASS_NAME: 'OpenLayers.Geometry.Point'}; 
     178        style = true; 
     179        r.drawGeometry(geometry, style); 
     180        t.ok(properDraw, "drawGeometry called drawPoint when passed a point"); 
     181 
     182        // line string 
     183        var properDraw = false; 
     184        r.drawLineString = function(g) { 
     185            properDraw = true; 
     186            return {}; 
     187        } 
     188        geometry = {CLASS_NAME: 'OpenLayers.Geometry.LineString'}; 
     189        style = true; 
     190        r.drawGeometry(geometry, style); 
     191        t.ok(properDraw, "drawGeometry called drawLineString when passed a line string"); 
     192 
     193        // linear ring 
     194        var properDraw = false; 
     195        r.drawLinearRing = function(g) { 
     196            properDraw = true; 
     197            return {}; 
     198        } 
     199        geometry = {CLASS_NAME: 'OpenLayers.Geometry.LinearRing'}; 
     200        style = true; 
     201        r.drawGeometry(geometry, style); 
     202        t.ok(properDraw, "drawGeometry called drawLinearRing when passed a linear ring"); 
     203 
     204        // polygon 
     205        var properDraw = false; 
     206        r.drawPolygon = function(g) { 
     207            properDraw = true; 
     208            return {}; 
     209        } 
     210        geometry = {CLASS_NAME: 'OpenLayers.Geometry.Polygon'}; 
     211        style = true; 
     212        r.drawGeometry(geometry, style); 
     213        t.ok(properDraw, "drawGeometry called drawPolygon when passed a polygon"); 
     214 
     215        // surface 
     216        var properDraw = false; 
     217        r.drawSurface = function(g) { 
     218            properDraw = true; 
     219            return {}; 
     220        } 
     221        geometry = {CLASS_NAME: 'OpenLayers.Geometry.Surface'}; 
     222        style = true; 
     223        r.drawGeometry(geometry, style); 
     224        t.ok(properDraw, "drawGeometry called drawSurface when passed a surface"); 
     225 
     226        // rectangle 
     227        var properDraw = false; 
     228        r.drawRectangle = function(g) { 
     229            properDraw = true; 
     230            return {}; 
     231        } 
     232        geometry = {CLASS_NAME: 'OpenLayers.Geometry.Rectangle'}; 
     233        style = true; 
     234        r.drawGeometry(geometry, style); 
     235        t.ok(properDraw, "drawGeometry called drawRectangle when passed a rectangle"); 
     236 
     237        // multi-point 
     238        var properDraw = false; 
     239        r.drawPoint = function(g) { 
     240            properDraw = true; 
     241            return {}; 
     242        } 
     243        geometry = { 
     244            CLASS_NAME: 'OpenLayers.Geometry.MultiPoint', 
     245            components: [{CLASS_NAME: 'OpenLayers.Geometry.Point'}] 
     246        }; 
     247        style = true; 
     248        r.drawGeometry(geometry, style); 
     249        t.ok(properDraw, "drawGeometry called drawPoint when passed a multi-point"); 
     250 
     251        // multi-linestring 
     252        var properDraw = false; 
     253        r.drawLineString = function(g) { 
     254            properDraw = true; 
     255            return {}; 
     256        } 
     257        geometry = { 
     258            CLASS_NAME: 'OpenLayers.Geometry.MultiLineString', 
     259            components: [{CLASS_NAME: 'OpenLayers.Geometry.LineString'}] 
     260        }; 
     261        style = true; 
     262        r.drawGeometry(geometry, style); 
     263        t.ok(properDraw, "drawGeometry called drawLineString when passed a multi-linestring"); 
     264 
     265        // multi-polygon 
     266        var properDraw = false; 
     267        r.drawPolygon = function(g) { 
     268            properDraw = true; 
     269            return {}; 
     270        } 
     271        geometry = { 
     272            CLASS_NAME: 'OpenLayers.Geometry.MultiPolygon', 
     273            components: [{CLASS_NAME: 'OpenLayers.Geometry.Polygon'}] 
     274        }; 
     275        style = true; 
     276        r.drawGeometry(geometry, style); 
     277        t.ok(properDraw, "drawGeometry called drawPolygon when passed a multi-polygon"); 
     278    } 
     279     
     280    function test_SVG_drawgeometrynode(t) { 
     281        t.plan(0); 
     282        // most of the tests for this method are already done in test_07_SVG_drawGeometry_2 
     283    } 
     284     
     285    function test_SVG_drawpoint(t) { 
     286        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     287            t.plan(0); 
     288            return; 
     289        } 
     290     
     291        t.plan(1); 
     292 
     293        var r = new OpenLayers.Renderer.SVG(document.body); 
     294         
     295        var properDraw = false; 
     296        var g_Radius = null; 
     297        r.drawCircle = function(n, g, r) { 
     298            properDraw = true; 
     299            g_Radius = 1; 
     300        } 
     301        r.drawPoint(); 
     302         
     303        t.ok(properDraw && g_Radius == 1, "drawPoint called drawCircle with radius set to 1"); 
     304    } 
     305     
     306    function test_SVG_drawcircle(t) { 
     307        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     308            t.plan(0); 
     309            return; 
     310        } 
     311         
     312        t.plan(3); 
     313         
     314        var r = new OpenLayers.Renderer.SVG(document.body); 
     315        r.resolution = 0.5; 
     316        r.left = 0; 
     317        r.top = 0; 
     318         
     319        var node = document.createElement('div'); 
     320         
     321        var geometry = { 
     322            x: 1, 
     323            y: 2 
     324        } 
     325         
     326        r.drawCircle(node, geometry, 3); 
     327         
     328        t.eq(node.getAttributeNS(null, 'cx'), '2', "cx is correct"); 
     329        t.eq(node.getAttributeNS(null, 'cy'), '4', "cy is correct"); 
     330        t.eq(node.getAttributeNS(null, 'r'), '3', "r is correct"); 
     331    } 
     332     
     333    function test_SVG_drawlinestring(t) { 
     334        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     335            t.plan(0); 
     336            return; 
     337        } 
     338         
     339        t.plan(2); 
     340         
     341        var r = new OpenLayers.Renderer.SVG(document.body); 
     342         
     343        var node = document.createElement('div'); 
     344         
     345        var geometry = { 
     346            components: "foo" 
     347        } 
     348        g_GetString = false; 
     349        g_Components = null; 
     350        r.getComponentsString = function(c) { 
     351            g_GetString = true; 
     352            g_Components = c; 
     353            return "bar"; 
     354        } 
     355         
     356        r.drawLineString(node, geometry); 
     357         
     358        t.ok(g_GetString && g_Components == "foo", "getComponentString is called with valid arguments"); 
     359        t.eq(node.getAttributeNS(null, "points"), "bar", "points attribute is correct"); 
     360    } 
     361     
     362    function test_SVG_drawlinearring(t) { 
     363        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     364            t.plan(0); 
     365            return; 
     366        } 
     367         
     368        t.plan(2); 
     369         
     370        var r = new OpenLayers.Renderer.SVG(document.body); 
     371         
     372        var node = document.createElement('div'); 
     373         
     374        var geometry = { 
     375            components: "foo" 
     376        } 
     377        g_GetString = false; 
     378        g_Components = null; 
     379        r.getComponentsString = function(c) { 
     380            g_GetString = true; 
     381            g_Components = c; 
     382            return "bar"; 
     383        } 
     384         
     385        r.drawLinearRing(node, geometry); 
     386         
     387        t.ok(g_GetString, "getComponentString is called with valid arguments"); 
     388        t.eq(node.getAttributeNS(null, "points"), "bar", "points attribute is correct"); 
     389    } 
     390 
     391    function test_SVG_drawpolygon(t) { 
     392        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     393            t.plan(0); 
     394            return; 
     395        } 
     396         
     397        t.plan(4); 
     398         
     399        var r = new OpenLayers.Renderer.SVG(document.body); 
     400         
     401        var node = document.createElement('div'); 
     402         
     403        var linearRings = [{ 
     404            components: ["foo"] 
     405        },{ 
     406            components: ["bar"] 
     407        }] 
     408         
     409        var geometry = { 
     410            components: linearRings 
     411        } 
     412        g_GetString = false; 
     413        r.getShortString = function(c) { 
     414            g_GetString = true; 
     415            return c; 
     416        } 
     417         
     418        r.drawPolygon(node, geometry); 
     419         
     420        t.ok(g_GetString, "getShortString is called"); 
     421        t.eq(node.getAttributeNS(null, "d"), " M foo M bar z", "d attribute is correctly set"); 
     422        t.eq(node.getAttributeNS(null, "fill-rule"), "evenodd", "fill-rule attribute is correctly set"); 
     423         
     424        r.getShortString = function(c) { 
     425            return false; 
     426        } 
     427        r.drawPolygon(node, geometry); 
     428        t.eq(node.getAttributeNS(null, "d"), "", "d attribute is empty if one linearRing cannot be drawn"); 
     429    } 
     430 
     431    function test_SVG_drawrectangle(t) { 
     432        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     433            t.plan(0); 
     434            return; 
     435        } 
     436         
     437        t.plan(4); 
     438         
     439        var r = new OpenLayers.Renderer.SVG(document.body); 
     440        r.resolution = 0.5; 
     441        r.left = 0; 
     442        r.top = 0; 
     443         
     444        var node = document.createElement('div'); 
     445         
     446        var geometry = { 
     447            x: 1, 
     448            y: 2, 
     449            width: 3, 
     450            height: 4 
     451        } 
     452         
     453        r.drawRectangle(node, geometry); 
     454         
     455        t.eq(node.getAttributeNS(null, "x"), "2", "x attribute is correctly set"); 
     456        t.eq(node.getAttributeNS(null, "y"), "4", "y attribute is correctly set"); 
     457        t.eq(node.getAttributeNS(null, "width"), "6", "width attribute is correctly set"); 
     458        t.eq(node.getAttributeNS(null, "height"), "8", "height attribute is correctly set"); 
     459    } 
     460     
     461    function test_SVG_drawsurface(t) { 
     462        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     463            t.plan(0); 
     464            return; 
     465        } 
     466         
     467        t.plan(3); 
     468         
     469        var r = new OpenLayers.Renderer.SVG(document.body); 
     470         
     471        var node = document.createElement('div'); 
     472         
     473        var geometry = { 
     474            components: ['foo', 'bar', 'dude'] 
     475        } 
     476        g_GetString = false; 
     477        r.getShortString = function(c) { 
     478            g_GetString = true; 
     479            return c; 
     480        } 
     481         
     482        r.drawSurface(node, geometry); 
     483         
     484        t.ok(g_GetString, "getShortString is called"); 
     485         
     486        t.eq(node.getAttributeNS(null, "d"), "M foo C bar dude Z", "d attribute is correctly set"); 
     487         
     488        r.getShortString = function(c) { 
     489            return false; 
     490        } 
     491        r.drawSurface(node, geometry); 
     492        t.eq(node.getAttributeNS(null, "d"), "", "d attribute is empty if one linearRing cannot be drawn"); 
     493    } 
     494     
     495    function test_SVG_getcomponentsstring(t) { 
     496        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     497            t.plan(0); 
     498            return; 
     499        } 
     500         
     501        t.plan(1); 
     502         
     503        var components = ['foo', 'bar']; 
     504         
     505        OpenLayers.Renderer.SVG.prototype._getShortString =  
     506            OpenLayers.Renderer.SVG.prototype.getShortString; 
     507             
     508        OpenLayers.Renderer.SVG.prototype.getShortString = function(p) { 
     509            return p; 
     510        }; 
     511         
     512        var string = OpenLayers.Renderer.SVG.prototype.getComponentsString(components); 
     513        t.eq(string, "foo,bar", "returned string is correct"); 
     514         
     515        OpenLayers.Renderer.SVG.prototype.getShortString =  
     516            OpenLayers.Renderer.SVG.prototype._getShortString; 
     517    } 
     518     
     519     
     520     
     521    function test_SVG_getshortstring(t) { 
     522        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     523            t.plan(0); 
     524            return; 
     525        } 
     526         
     527        t.plan(1); 
     528         
     529        var r = new OpenLayers.Renderer.SVG(document.body); 
     530        r.resolution = 0.5; 
     531        r.left = 0; 
     532        r.top = 0; 
     533         
     534        var point = { 
     535            x: 1, 
     536            y: 2 
     537        }; 
     538         
     539        var string = r.getShortString(point); 
     540        t.eq(string, "2,4", "returned string is correct"); 
     541    } 
     542     
     543     
     544 
     545  </script> 
     546</head> 
     547<body> 
     548<div id="map" style="width:500px;height:550px"></div> 
     549</body> 
     550</html> 

  • tests/Renderer/test_Elements.html

    old new  
     1<html> 
     2<head> 
     3<script src="../../lib/OpenLayers.js"></script> 
     4  <script type="text/javascript"> 
     5 
     6    function test_Elements_constructor(t) { 
     7        t.plan(5); 
     8        var el = document.body; 
     9        el.id = "foo"; 
     10         
     11        OpenLayers.Renderer.Elements.prototype._createRenderRoot = 
     12            OpenLayers.Renderer.Elements.prototype.createRenderRoot; 
     13         
     14        var rendererRoot = document.createElement("div"); 
     15        OpenLayers.Renderer.Elements.prototype.createRenderRoot = function() { 
     16            return rendererRoot; 
     17        } 
     18         
     19        OpenLayers.Renderer.Elements.prototype._createRoot = 
     20            OpenLayers.Renderer.Elements.prototype.createRoot; 
     21         
     22        var root = document.createElement("div"); 
     23        OpenLayers.Renderer.Elements.prototype.createRoot = function() { 
     24            return root; 
     25        } 
     26         
     27        var r = new OpenLayers.Renderer.Elements("foo"); 
     28         
     29        t.ok(r instanceof OpenLayers.Renderer.Elements, "new OpenLayers.Renderer.Elements returns Elements object" ); 
     30        t.ok(r.rendererRoot != null, "elements rendererRoot is not null"); 
     31        t.ok(r.root != null, "elements root is not null"); 
     32         
     33        t.ok(r.root.parentNode == rendererRoot, "elements root is correctly appended to rendererRoot"); 
     34        t.ok(r.rendererRoot.parentNode == document.body, "elements rendererRoot is correctly appended to container"); 
     35         
     36        OpenLayers.Renderer.Elements.prototype.createRenderRoot = 
     37            OpenLayers.Renderer.Elements.prototype._createRenderRoot; 
     38        OpenLayers.Renderer.Elements.prototype.createRoot = 
     39            OpenLayers.Renderer.Elements.prototype._createRoot; 
     40    } 
     41     
     42    function test_Elements_clear(t) { 
     43        t.plan(1); 
     44         
     45        OpenLayers.Renderer.Elements.prototype._initialize = 
     46            OpenLayers.Renderer.Elements.prototype.initialize; 
     47         
     48        OpenLayers.Renderer.Elements.prototype.initialize = function() {} 
     49         
     50        var r = new OpenLayers.Renderer.Elements(); 
     51        var element = document.createElement("div"); 
     52        r.root = element; 
     53         
     54        var node = document.createElement("div"); 
     55        element.appendChild(node); 
     56         
     57        r.clear(); 
     58         
     59        t.ok(r.root.childNodes.length == 0, "Elements is correctly cleared"); 
     60         
     61        OpenLayers.Renderer.Elements.prototype.initialize = 
     62            OpenLayers.Renderer.Elements.prototype._initialize; 
     63    } 
     64     
     65    function test_Elements_getfeatureidfromevent(t) { 
     66        t.plan(2); 
     67         
     68        var node = { 
     69            _featureId: 'foo' 
     70        } 
     71        var event = { 
     72            target: node 
     73        } 
     74         
     75        var id = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent(event); 
     76        t.eq(id, 'foo', "returned id is correct when event with target is passed"); 
     77         
     78        var event = { 
     79            srcElement: node 
     80        } 
     81         
     82        var id = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent(event); 
     83        t.eq(id, 'foo', "returned id is correct when event with srcElement is passed"); 
     84    } 
     85     
     86    function test_Elements_erasegeometry(t) { 
     87        t.plan(4); 
     88         
     89        var el = document.createElement('div'); 
     90        document.body.appendChild(el); 
     91        el.id = 'foo'; 
     92        var geometry = { 
     93            id: 'foo' 
     94        }; 
     95         
     96        OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
     97        t.ok(el.parentNode != document.body, "element correctly removed"); 
     98 
     99 
     100        var el = document.createElement('div'); 
     101        document.body.appendChild(el); 
     102        el.id = 'foo'; 
     103        var geometry = { 
     104            CLASS_NAME: "OpenLayers.Geometry.MultiPoint", 
     105            components: [{ 
     106                id: 'foo' 
     107            }] 
     108        }; 
     109 
     110        OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
     111        t.ok(el.parentNode != document.body, "geometry components correctly removed when passed a multipoint"); 
     112         
     113        var el = document.createElement('div'); 
     114        document.body.appendChild(el); 
     115        el.id = 'foo'; 
     116        var geometry = { 
     117            CLASS_NAME: "OpenLayers.Geometry.MultiLineString", 
     118            components: [{ 
     119                id: 'foo' 
     120            }] 
     121        }; 
     122         
     123        OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
     124        t.ok(el.parentNode != document.body, "geometry components correctly removed when passed a multilinestring"); 
     125         
     126        var el = document.createElement('div'); 
     127        document.body.appendChild(el); 
     128        el.id = 'foo'; 
     129        var geometry = { 
     130            CLASS_NAME: "OpenLayers.Geometry.MultiPolygon", 
     131            components: [{ 
     132                id: 'foo' 
     133            }] 
     134        }; 
     135         
     136        OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
     137        t.ok(el.parentNode != document.body, "geometry components correctly removed when passed a multipolygon"); 
     138    }     
     139 
     140  </script> 
     141</head> 
     142<body> 
     143<div id="map" style="width:500px;height:550px"></div> 
     144</body> 
     145</html> 

  • tests/test_Renderer.html

    old new  
    33<script src="../lib/OpenLayers.js"></script> 
    44  <script type="text/javascript"> 
    55 
    6     var layer; 
    7  
    8     function test_01_Renderer_drawGeometry(t) { 
    9         t.plan(1);  
     6    function test_01_Renderer_constructor(t) { 
     7        t.plan(2); 
     8        var el = document.body; 
     9        el.id = "foo"; 
     10        var r = new OpenLayers.Renderer(el.id); 
     11         
     12        t.ok(r instanceof OpenLayers.Renderer, "new OpenLayers.Renderer returns Renderer object" ); 
     13        t.ok(r.container == el, "renderer container is correctly set"); 
     14    } 
     15     
     16    function test_02_Renderer_supported(t) { 
     17        t.plan(1); 
     18         
    1019        var r = new OpenLayers.Renderer(); 
    11         t.ok( r instanceof OpenLayers.Renderer, "new OpenLayers.Renderer returns REnderer object" ); 
     20        t.eq(r.supported(), false, "supported returns false by default"); 
    1221    } 
    13  
    14 /*  
    15 function test_01_Renderer_drawGeometry(t) { 
    16         t.plan(12);  
    17  
     22     
     23    function test_03_Renderer_setextent(t) { 
     24        t.plan(2); 
     25         
    1826        var r = new OpenLayers.Renderer(); 
    19         r.root = document.body; 
    20         r.setStyle = function() {}; 
     27        var extent = new OpenLayers.Bounds(1,2,3,4); 
     28        r.resolution = 1; 
     29        r.setExtent(extent); 
     30        t.ok(r.extent.equals(extent), "extent is correctly set"); 
     31        t.eq(r.resolution, null, "resolution nullified"); 
     32    } 
     33     
     34    function test_04_Renderer_setsize(t) { 
     35        t.plan(2); 
    2136         
    22         var geometry = null;  
    23         var style = null;  
     37        var r = new OpenLayers.Renderer(); 
     38        var size = new OpenLayers.Size(1,2); 
     39        r.resolution = 1; 
     40        r.setSize(size); 
     41        t.ok(r.size.equals(size), "size is correctly set"); 
     42        t.eq(r.resolution, null, "resolution nullified"); 
     43    } 
    2444     
    25         r.drawGeometry(geometry, style);  
    26         t.ok(true, "didnt do anything on null style"); 
     45    function test_05_Renderer_getresolution(t) { 
     46        t.plan(2); 
    2747         
    28         // point 
    29         var properDraw = false; 
    30         r.drawPoint = function(g) { 
    31             properDraw = true; 
    32             return {}; 
    33         } 
    34         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Point'}; 
    35         style = true;  
    36         r.drawGeometry(geometry, style); 
    37         t.ok(properDraw, "drawGeometry called drawPoint when passed a point"); 
     48        var r = new OpenLayers.Renderer(); 
     49        var map = new OpenLayers.Map("map"); 
     50        r.map = map; 
     51        var resolution = r.getResolution(); 
     52        t.eq(resolution, map.getResolution(), "resolution matches the map resolution"); 
     53        t.eq(r.resolution, resolution, "resolution is correctly set"); 
     54    } 
    3855 
    39         // curve 
    40         var properDraw = false; 
    41         r.drawCurve = function(g) { 
    42             properDraw = true; 
    43             return {}; 
    44         }  
    45         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Curve'}; 
    46         style = true;  
    47         r.drawGeometry(geometry, style); 
    48         t.ok(properDraw, "drawGeometry called drawCurve when passed a curve"); 
     56    function test_99_Renderer_destroy(t) { 
     57        t.plan(5); 
    4958 
    50         // line segment 
    51         var properDraw = false; 
    52         r.drawLineString = function(g) { 
    53             properDraw = true; 
    54             return {}; 
    55         } 
    56         geometry = {CLASS_NAME: 'OpenLayers.Geometry.LineSegment'}; 
    57         style = true; 
    58         r.drawGeometry(geometry, style); 
    59         t.ok(properDraw, "drawGeometry called drawLineString when passed a line segment"); 
     59        var r = new OpenLayers.Renderer(); 
     60        r.container = document.createElement("div"); 
     61        r.extent = new OpenLayers.Bounds(1,2,3,4); 
     62        r.size = new OpenLayers.Size(1,2); 
     63        r.resolution = 1; 
     64        r.map = {}; 
    6065 
    61         // line string 
    62         var properDraw = false; 
    63         r.drawLineString = function(g) { 
    64             properDraw = true; 
    65             return {}; 
    66         } 
    67         geometry = {CLASS_NAME: 'OpenLayers.Geometry.LineString'}; 
    68         style = true; 
    69         r.drawGeometry(geometry, style); 
    70         t.ok(properDraw, "drawGeometry called drawLineString when passed a line string"); 
     66        r.destroy(); 
    7167 
    72         // linear ring 
    73         var properDraw = false; 
    74         r.drawLinearRing = function(g) { 
    75             properDraw = true; 
    76             return {}; 
    77         } 
    78         geometry = {CLASS_NAME: 'OpenLayers.Geometry.LinearRing'}; 
    79         style = true; 
    80         r.drawGeometry(geometry, style); 
    81         t.ok(properDraw, "drawGeometry called drawLinearRing when passed a linear ring"); 
    82  
    83         // polygon 
    84         var properDraw = false; 
    85         r.drawPolygon = function(g) { 
    86             properDraw = true; 
    87             return {}; 
    88         } 
    89         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Polygon'}; 
    90         style = true; 
    91         r.drawGeometry(geometry, style); 
    92         t.ok(properDraw, "drawGeometry called drawPolygon when passed a polygon"); 
    93  
    94         // surface 
    95         var properDraw = false; 
    96         r.drawSurface = function(g) { 
    97             properDraw = true; 
    98             return {}; 
    99         } 
    100         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Surface'}; 
    101         style = true; 
    102         r.drawGeometry(geometry, style); 
    103         t.ok(properDraw, "drawGeometry called drawSurface when passed a surface"); 
    104  
    105         // rectangle 
    106         var properDraw = false; 
    107         r.drawRectangle = function(g) { 
    108             properDraw = true; 
    109             return {}; 
    110         } 
    111         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Rectangle'}; 
    112         style = true; 
    113         r.drawGeometry(geometry, style); 
    114         t.ok(properDraw, "drawGeometry called drawRectangle when passed a rectangle"); 
    115  
    116         // multi-point 
    117         var properDraw = false; 
    118         r.drawPoint = function(g) { 
    119             properDraw = true; 
    120             return {}; 
    121         } 
    122         geometry = { 
    123             CLASS_NAME: 'OpenLayers.Geometry.MultiPoint', 
    124             components: [{CLASS_NAME: 'OpenLayers.Geometry.Point'}] 
    125         }; 
    126         style = true; 
    127         r.drawGeometry(geometry, style); 
    128         t.ok(properDraw, "drawGeometry called drawPoint when passed a multi-point"); 
    129  
    130         // multi-linestring 
    131         var properDraw = false; 
    132         r.drawLineString = function(g) { 
    133             properDraw = true; 
    134             return {}; 
    135         } 
    136         geometry = { 
    137             CLASS_NAME: 'OpenLayers.Geometry.MultiLineString', 
    138             components: [{CLASS_NAME: 'OpenLayers.Geometry.LineString'}] 
    139         }; 
    140         style = true; 
    141         r.drawGeometry(geometry, style); 
    142         t.ok(properDraw, "drawGeometry called drawLineString when passed a multi-linestring"); 
    143  
    144         // multi-polygon 
    145         var properDraw = false; 
    146         r.drawPolygon = function(g) { 
    147             properDraw = true; 
    148             return {}; 
    149         } 
    150         geometry = { 
    151             CLASS_NAME: 'OpenLayers.Geometry.MultiPolygon', 
    152             components: [{CLASS_NAME: 'OpenLayers.Geometry.Polygon'}] 
    153         }; 
    154         style = true; 
    155         r.drawGeometry(geometry, style); 
    156         t.ok(properDraw, "drawGeometry called drawPolygon when passed a multi-polygon"); 
    157  
     68        t.eq(r.container, null, "container nullified"); 
     69        t.eq(r.extent, null, "extent nullified"); 
     70        t.eq(r.size, null, "size nullified"); 
     71        t.eq(r.resolution, null, "resolution nullified"); 
     72        t.eq(r.map, null, "map nullified"); 
    15873    } 
    159      */ 
    16074 
    16175  </script> 
    16276</head> 

  • tests/list-tests.html

    old new  
    8787    <li>Handler/test_Path.html</li> 
    8888    <li>Handler/test_Polygon.html</li> 
    8989    <li>Handler/test_RegularPolygon.html</li> 
     90    <li>Renderer/test_Elements.html</li> 
     91    <li>Renderer/test_SVG.html</li> 
    9092    <li>test_Map.html</li> 
    9193</ul>