OpenLayers OpenLayers

Ticket #1128: renderers_tests.patch

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

(complete) tests for Renderer, Elements, SVG, VML

  • tests/Renderer/test_VML.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_VML_constructor(t) { 
     9        if (!OpenLayers.Renderer.VML.prototype.supported()) { 
     10            t.plan(0); 
     11            return; 
     12        } 
     13         
     14        t.plan(1); 
     15        var r = new OpenLayers.Renderer.VML(document.body); 
     16        t.ok(r instanceof OpenLayers.Renderer.VML, "new OpenLayers.Renderer.VML returns VML object" ); 
     17    } 
     18     
     19    function test_VML_destroy(t) { 
     20        if (!OpenLayers.Renderer.VML.prototype.supported()) { 
     21            t.plan(0); 
     22            return; 
     23        } 
     24         
     25        t.plan(1); 
     26         
     27        var g_Destroy = false; 
     28         
     29        OpenLayers.Renderer.Elements.prototype._destroy =  
     30            OpenLayers.Renderer.Elements.prototype.destroy; 
     31             
     32        OpenLayers.Renderer.prototype.destroy = function() { 
     33            g_Destroy = true; 
     34        } 
     35         
     36        var r = new OpenLayers.Renderer.VML(document.body); 
     37        r.destroy(); 
     38         
     39        t.eq(g_Destroy, true, "OpenLayers.Renderer.Elements.destroy() called"); 
     40         
     41        OpenLayers.Renderer.prototype.destroy =  
     42            OpenLayers.Renderer.prototype._destroy; 
     43    } 
     44     
     45    function test_VML_setextent(t) { 
     46        if (!OpenLayers.Renderer.VML.prototype.supported()) { 
     47            t.plan(0); 
     48            return; 
     49        } 
     50         
     51        t.plan(3); 
     52         
     53        OpenLayers.Renderer.Elements.prototype._setExtent = 
     54            OpenLayers.Renderer.Elements.prototype.setExtent; 
     55         
     56        var g_SetExtent = false; 
     57        OpenLayers.Renderer.Elements.prototype.setExtent = function() { 
     58            g_SetExtent = true; 
     59        } 
     60                 
     61        var r = new OpenLayers.Renderer.VML(document.body); 
     62        r.map = { 
     63            getResolution: function() { 
     64                return 0.5; 
     65            } 
     66        } 
     67         
     68        var extent = new OpenLayers.Bounds(1,2,3,4); 
     69        r.setExtent(extent); 
     70         
     71        t.eq(g_SetExtent, true, "Elements.setExtent() called"); 
     72         
     73        t.ok(r.root.coordorigin == "2,8", "coordorigin is correct"); 
     74        t.ok(r.root.coordsize == "4,-4", "coordsize is correct"); 
     75         
     76        OpenLayers.Renderer.Elements.prototype.setExtent = 
     77            OpenLayers.Renderer.Elements.prototype._setExtent; 
     78    } 
     79 
     80    function test_VML_setsize(t) { 
     81        if (!OpenLayers.Renderer.VML.prototype.supported()) { 
     82            t.plan(0); 
     83            return; 
     84        } 
     85         
     86        t.plan(4); 
     87                 
     88        var r = new OpenLayers.Renderer.VML(document.body); 
     89         
     90        var size = new OpenLayers.Size(1,2); 
     91        r.setSize(size); 
     92        t.eq(r.rendererRoot.style.width, "1px", "rendererRoot width is correct"); 
     93        t.eq(r.rendererRoot.style.height, "2px", "rendererRoot height is correct"); 
     94         
     95        t.eq(r.root.style.width, "100%", "root width is correct"); 
     96        t.eq(r.root.style.height, "100%", "root height is correct"); 
     97    } 
     98 
     99    function test_VML_drawpoint(t) { 
     100        if (!OpenLayers.Renderer.VML.prototype.supported()) { 
     101            t.plan(0); 
     102            return; 
     103        } 
     104     
     105        t.plan(1); 
     106 
     107        var r = new OpenLayers.Renderer.VML(document.body); 
     108         
     109        var properDraw = false; 
     110        var g_Radius = null; 
     111        r.drawCircle = function(n, g, r) { 
     112            properDraw = true; 
     113            g_Radius = 1; 
     114        } 
     115        r.drawPoint(); 
     116         
     117        t.ok(properDraw && g_Radius == 1, "drawPoint called drawCircle with radius set to 1"); 
     118    } 
     119 
     120    function test_VML_drawcircle(t) { 
     121        if (!OpenLayers.Renderer.VML.prototype.supported()) { 
     122            t.plan(0); 
     123            return; 
     124        } 
     125         
     126        t.plan(4); 
     127         
     128        var r = new OpenLayers.Renderer.VML(document.body); 
     129        r.resolution = 0.5; 
     130         
     131        var node = document.createElement('div'); 
     132         
     133        var geometry = { 
     134            x: 1, 
     135            y: 2 
     136        } 
     137         
     138        var radius = 3; 
     139        r.drawCircle(node, geometry, radius); 
     140         
     141        t.eq(node.style.left, '-1px', "left is correct"); 
     142        t.eq(node.style.top, '1px', "top is correct"); 
     143        t.eq(node.style.width, (2 * radius) + "px", "width is correct"); 
     144        t.eq(node.style.height, (2 * radius) + "px", "height is correct"); 
     145    } 
     146 
     147    function test_VML_drawlinestring(t) { 
     148        if (!OpenLayers.Renderer.VML.prototype.supported()) { 
     149            t.plan(0); 
     150            return; 
     151        } 
     152         
     153        t.plan(1); 
     154         
     155        var r = new OpenLayers.Renderer.VML(document.body); 
     156         
     157        g_DrawLine = false; 
     158        r.drawLine = function(c) { 
     159            g_DrawLine = true; 
     160        } 
     161         
     162        r.drawLineString(node, geometry); 
     163         
     164        t.ok(g_DrawLine, "drawLine is called"); 
     165    } 
     166     
     167    function test_VML_drawlinearring(t) { 
     168        if (!OpenLayers.Renderer.VML.prototype.supported()) { 
     169            t.plan(0); 
     170            return; 
     171        } 
     172         
     173        t.plan(1); 
     174         
     175        var r = new OpenLayers.Renderer.VML(document.body); 
     176         
     177        g_DrawLine = false; 
     178        r.drawLine = function(c) { 
     179            g_DrawLine = true; 
     180        } 
     181         
     182        r.drawLinearRing(node, geometry); 
     183         
     184        t.ok(g_DrawLine, "drawLine is called"); 
     185    } 
     186 
     187    function test_VML_drawline(t) { 
     188        if (!OpenLayers.Renderer.VML.prototype.supported()) { 
     189            t.plan(0); 
     190            return; 
     191        } 
     192         
     193        t.plan(8); 
     194         
     195        var r = new OpenLayers.Renderer.VML(document.body); 
     196        r.resolution = 0.5; 
     197         
     198        var node = document.createElement('div'); 
     199         
     200        var geometry = { 
     201            components: [{ 
     202                x: 1, 
     203                y: 2 
     204            },{ 
     205                x: 3, 
     206                y: 4 
     207            }], 
     208            getBounds: function() { 
     209                return new OpenLayers.Bounds(5,6,7,8); 
     210            } 
     211        }; 
     212         
     213        r.drawLine(node, geometry, true); 
     214        t.ok(node.path.indexOf("x") != -1, "path attribute is correct when passed closeLine = true"); 
     215         
     216         
     217        r.drawLine(node, geometry, false); 
     218        t.eq(node.path, "m 2,4 l  6,8 l  e", "path attribute is correct"); 
     219        t.eq(node.style.left, "10px", "node.style.left is correct"); 
     220        t.eq(node.style.top, "16px", "node.style.top is correct"); 
     221        t.eq(node.style.width, "4px", "node.style.width is correct"); 
     222        t.eq(node.style.height, "4px", "node.style.height is correct"); 
     223        t.eq(node.coordorigin, "10 16", "node.coordorigin is correct"); 
     224        t.eq(node.coordsize, "4 4", "node.coordsize is correct"); 
     225    } 
     226     
     227    function test_VML_drawpolygon(t) { 
     228        if (!OpenLayers.Renderer.VML.prototype.supported()) { 
     229            t.plan(0); 
     230            return; 
     231        } 
     232         
     233        t.plan(2); 
     234         
     235        var r = new OpenLayers.Renderer.VML(document.body); 
     236        r.resolution = 0.5; 
     237         
     238        g_SetNodeDimension = false; 
     239        r.setNodeDimension = function(){ 
     240            g_SetNodeDimension = true; 
     241        }; 
     242         
     243        var node = document.createElement('div'); 
     244         
     245        var linearRing = { 
     246            components: [{ 
     247                x: 1, 
     248                y: 2 
     249            },{ 
     250                x: 3, 
     251                y: 4 
     252            }] 
     253        }; 
     254        var linearRing2 = { 
     255            components: [{ 
     256                x: 5, 
     257                y: 6 
     258            },{ 
     259                x: 7, 
     260                y: 8 
     261            }] 
     262        }; 
     263        var geometry = { 
     264            components: [linearRing, linearRing2] 
     265        }; 
     266        r.drawPolygon(node, geometry, true); 
     267        t.ok(g_SetNodeDimension, "setNodeDimension is called"); 
     268        t.eq(node.path, "m 2,4 l 6,8 x m 10,12 l 14,16 x e", "path attribute is correct"); 
     269    } 
     270     
     271    function test_VML_drawrectangle(t) { 
     272        if (!OpenLayers.Renderer.VML.prototype.supported()) { 
     273            t.plan(0); 
     274            return; 
     275        } 
     276         
     277        t.plan(4); 
     278         
     279        var r = new OpenLayers.Renderer.VML(document.body); 
     280        r.resolution = 0.5; 
     281         
     282        var node = document.createElement('div'); 
     283         
     284        var geometry = { 
     285            x: 1, 
     286            y: 2, 
     287            width: 3, 
     288            height: 4 
     289        } 
     290         
     291        r.drawRectangle(node, geometry); 
     292         
     293        t.eq(node.style.left, "2px", "node.style.left is correct"); 
     294        t.eq(node.style.top, "4px", "node.style.top is correct"); 
     295        t.eq(node.style.width, "6px", "node.style.width is correct"); 
     296        t.eq(node.style.height, "8px", "node.style.height is correct"); 
     297    } 
     298     
     299 
     300  </script> 
     301</head> 
     302<body> 
     303<div id="map" style="width:500px;height:550px"></div> 
     304</body> 
     305</html> 

  • 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(1); 
     26         
     27        var g_Destroy = false; 
     28         
     29        OpenLayers.Renderer.Elements.prototype._destroy =  
     30            OpenLayers.Renderer.Elements.prototype.destroy; 
     31             
     32        OpenLayers.Renderer.prototype.destroy = function() { 
     33            g_Destroy = true; 
     34        } 
     35         
     36        var r = new OpenLayers.Renderer.SVG(document.body); 
     37        r.destroy(); 
     38         
     39        t.eq(g_Destroy, true, "OpenLayers.Renderer.Elements.destroy() called"); 
     40         
     41        OpenLayers.Renderer.prototype.destroy =  
     42            OpenLayers.Renderer.prototype._destroy; 
     43    } 
     44     
     45    function test_SVG_setextent(t) { 
     46        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     47            t.plan(0); 
     48            return; 
     49        } 
     50         
     51        t.plan(5); 
     52         
     53        OpenLayers.Renderer.Elements.prototype._setExtent = 
     54            OpenLayers.Renderer.Elements.prototype.setExtent; 
     55         
     56        var g_SetExtent = false; 
     57        OpenLayers.Renderer.Elements.prototype.setExtent = function() { 
     58            g_SetExtent = true; 
     59        } 
     60                 
     61        var r = new OpenLayers.Renderer.SVG(document.body); 
     62        r.map = { 
     63            getResolution: function() { 
     64                return 0.5; 
     65            } 
     66        } 
     67         
     68        var extent = new OpenLayers.Bounds(1,2,3,4); 
     69        r.setExtent(extent); 
     70         
     71        t.eq(g_SetExtent, true, "Elements.setExtent() called"); 
     72         
     73        t.eq(r.left, -2, "left is correct"); 
     74        t.eq(r.top, 8, "top is correct"); 
     75         
     76        t.eq(r.rendererRoot.getAttributeNS(null, "viewBox"), "0 0 4 4", "rendererRoot viewBox is correct"); 
     77         
     78        // test extent changes 
     79        var extent = new OpenLayers.Bounds(4,3,2,1); 
     80        r.setExtent(extent); 
     81        t.eq(r.rendererRoot.getAttributeNS(null, "viewBox"), "6 6 -4 -4", "rendererRoot viewBox is correct after a new setExtent"); 
     82 
     83        OpenLayers.Renderer.Elements.prototype.setExtent = 
     84            OpenLayers.Renderer.Elements.prototype._setExtent; 
     85    } 
     86     
     87    function test_SVG_setsize(t) { 
     88        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     89            t.plan(0); 
     90            return; 
     91        } 
     92         
     93        t.plan(2); 
     94                 
     95        var r = new OpenLayers.Renderer.SVG(document.body); 
     96         
     97        var size = new OpenLayers.Size(1,2); 
     98        r.setSize(size); 
     99        t.eq(r.rendererRoot.getAttributeNS(null, "width"), size.w.toString(), "width is correct"); 
     100        t.eq(r.rendererRoot.getAttributeNS(null, "height"), size.h.toString(), "height is correct"); 
     101    } 
     102     
     103    function test_SVG_drawpoint(t) { 
     104        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     105            t.plan(0); 
     106            return; 
     107        } 
     108     
     109        t.plan(1); 
     110 
     111        var r = new OpenLayers.Renderer.SVG(document.body); 
     112         
     113        var properDraw = false; 
     114        var g_Radius = null; 
     115        r.drawCircle = function(n, g, r) { 
     116            properDraw = true; 
     117            g_Radius = 1; 
     118        } 
     119        r.drawPoint(); 
     120         
     121        t.ok(properDraw && g_Radius == 1, "drawPoint called drawCircle with radius set to 1"); 
     122    } 
     123     
     124    function test_SVG_drawcircle(t) { 
     125        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     126            t.plan(0); 
     127            return; 
     128        } 
     129         
     130        t.plan(3); 
     131         
     132        var r = new OpenLayers.Renderer.SVG(document.body); 
     133        r.resolution = 0.5; 
     134        r.left = 0; 
     135        r.top = 0; 
     136         
     137        var node = document.createElement('div'); 
     138         
     139        var geometry = { 
     140            x: 1, 
     141            y: 2 
     142        } 
     143         
     144        r.drawCircle(node, geometry, 3); 
     145         
     146        t.eq(node.getAttributeNS(null, 'cx'), '2', "cx is correct"); 
     147        t.eq(node.getAttributeNS(null, 'cy'), '4', "cy is correct"); 
     148        t.eq(node.getAttributeNS(null, 'r'), '3', "r is correct"); 
     149    } 
     150     
     151    function test_SVG_drawlinestring(t) { 
     152        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     153            t.plan(0); 
     154            return; 
     155        } 
     156         
     157        t.plan(2); 
     158         
     159        var r = new OpenLayers.Renderer.SVG(document.body); 
     160         
     161        var node = document.createElement('div'); 
     162         
     163        var geometry = { 
     164            components: "foo" 
     165        } 
     166        g_GetString = false; 
     167        g_Components = null; 
     168        r.getComponentsString = function(c) { 
     169            g_GetString = true; 
     170            g_Components = c; 
     171            return "bar"; 
     172        } 
     173         
     174        r.drawLineString(node, geometry); 
     175         
     176        t.ok(g_GetString && g_Components == "foo", "getComponentString is called with valid arguments"); 
     177        t.eq(node.getAttributeNS(null, "points"), "bar", "points attribute is correct"); 
     178    } 
     179     
     180    function test_SVG_drawlinearring(t) { 
     181        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     182            t.plan(0); 
     183            return; 
     184        } 
     185         
     186        t.plan(2); 
     187         
     188        var r = new OpenLayers.Renderer.SVG(document.body); 
     189         
     190        var node = document.createElement('div'); 
     191         
     192        var geometry = { 
     193            components: "foo" 
     194        } 
     195        g_GetString = false; 
     196        g_Components = null; 
     197        r.getComponentsString = function(c) { 
     198            g_GetString = true; 
     199            g_Components = c; 
     200            return "bar"; 
     201        } 
     202         
     203        r.drawLinearRing(node, geometry); 
     204         
     205        t.ok(g_GetString, "getComponentString is called with valid arguments"); 
     206        t.eq(node.getAttributeNS(null, "points"), "bar", "points attribute is correct"); 
     207    } 
     208 
     209    function test_SVG_drawpolygon(t) { 
     210        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     211            t.plan(0); 
     212            return; 
     213        } 
     214         
     215        t.plan(4); 
     216         
     217        var r = new OpenLayers.Renderer.SVG(document.body); 
     218         
     219        var node = document.createElement('div'); 
     220         
     221        var linearRings = [{ 
     222            components: ["foo"] 
     223        },{ 
     224            components: ["bar"] 
     225        }] 
     226         
     227        var geometry = { 
     228            components: linearRings 
     229        } 
     230        g_GetString = false; 
     231        r.getShortString = function(c) { 
     232            g_GetString = true; 
     233            return c; 
     234        } 
     235         
     236        r.drawPolygon(node, geometry); 
     237         
     238        t.ok(g_GetString, "getShortString is called"); 
     239        t.eq(node.getAttributeNS(null, "d"), " M foo M bar z", "d attribute is correctly set"); 
     240        t.eq(node.getAttributeNS(null, "fill-rule"), "evenodd", "fill-rule attribute is correctly set"); 
     241         
     242        r.getShortString = function(c) { 
     243            return false; 
     244        } 
     245        r.drawPolygon(node, geometry); 
     246        t.eq(node.getAttributeNS(null, "d"), "", "d attribute is empty if one linearRing cannot be drawn"); 
     247    } 
     248 
     249    function test_SVG_drawrectangle(t) { 
     250        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     251            t.plan(0); 
     252            return; 
     253        } 
     254         
     255        t.plan(4); 
     256         
     257        var r = new OpenLayers.Renderer.SVG(document.body); 
     258        r.resolution = 0.5; 
     259        r.left = 0; 
     260        r.top = 0; 
     261         
     262        var node = document.createElement('div'); 
     263         
     264        var geometry = { 
     265            x: 1, 
     266            y: 2, 
     267            width: 3, 
     268            height: 4 
     269        } 
     270         
     271        r.drawRectangle(node, geometry); 
     272         
     273        t.eq(node.getAttributeNS(null, "x"), "2", "x attribute is correctly set"); 
     274        t.eq(node.getAttributeNS(null, "y"), "4", "y attribute is correctly set"); 
     275        t.eq(node.getAttributeNS(null, "width"), "6", "width attribute is correctly set"); 
     276        t.eq(node.getAttributeNS(null, "height"), "8", "height attribute is correctly set"); 
     277    } 
     278     
     279    function test_SVG_drawsurface(t) { 
     280        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     281            t.plan(0); 
     282            return; 
     283        } 
     284         
     285        t.plan(3); 
     286         
     287        var r = new OpenLayers.Renderer.SVG(document.body); 
     288         
     289        var node = document.createElement('div'); 
     290         
     291        var geometry = { 
     292            components: ['foo', 'bar', 'dude'] 
     293        } 
     294        g_GetString = false; 
     295        r.getShortString = function(c) { 
     296            g_GetString = true; 
     297            return c; 
     298        } 
     299         
     300        r.drawSurface(node, geometry); 
     301         
     302        t.ok(g_GetString, "getShortString is called"); 
     303         
     304        t.eq(node.getAttributeNS(null, "d"), "M foo C bar dude Z", "d attribute is correctly set"); 
     305         
     306        r.getShortString = function(c) { 
     307            return false; 
     308        } 
     309        r.drawSurface(node, geometry); 
     310        t.eq(node.getAttributeNS(null, "d"), "", "d attribute is empty if one linearRing cannot be drawn"); 
     311    } 
     312     
     313    function test_SVG_getcomponentsstring(t) { 
     314        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     315            t.plan(0); 
     316            return; 
     317        } 
     318         
     319        t.plan(1); 
     320         
     321        var components = ['foo', 'bar']; 
     322         
     323        OpenLayers.Renderer.SVG.prototype._getShortString =  
     324            OpenLayers.Renderer.SVG.prototype.getShortString; 
     325             
     326        OpenLayers.Renderer.SVG.prototype.getShortString = function(p) { 
     327            return p; 
     328        }; 
     329         
     330        var string = OpenLayers.Renderer.SVG.prototype.getComponentsString(components); 
     331        t.eq(string, "foo,bar", "returned string is correct"); 
     332         
     333        OpenLayers.Renderer.SVG.prototype.getShortString =  
     334            OpenLayers.Renderer.SVG.prototype._getShortString; 
     335    } 
     336     
     337     
     338     
     339    function test_SVG_getshortstring(t) { 
     340        if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
     341            t.plan(0); 
     342            return; 
     343        } 
     344         
     345        t.plan(1); 
     346         
     347        var r = new OpenLayers.Renderer.SVG(document.body); 
     348        r.resolution = 0.5; 
     349        r.left = 0; 
     350        r.top = 0; 
     351         
     352        var point = { 
     353            x: 1, 
     354            y: 2 
     355        }; 
     356         
     357        var string = r.getShortString(point); 
     358        t.eq(string, "2,4", "returned string is correct"); 
     359    } 
     360     
     361     
     362 
     363  </script> 
     364</head> 
     365<body> 
     366<div id="map" style="width:500px;height:550px"></div> 
     367</body> 
     368</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_destroy(t) { 
     43        t.plan(5); 
     44         
     45        OpenLayers.Renderer.Elements.prototype._initialize = 
     46            OpenLayers.Renderer.Elements.prototype.initialize; 
     47         
     48        OpenLayers.Renderer.Elements.prototype.initialize = function() {} 
     49         
     50        var g_Clear = false, g_Destroy = false; 
     51         
     52        OpenLayers.Renderer.prototype._destroy =  
     53            OpenLayers.Renderer.prototype.destroy; 
     54             
     55        OpenLayers.Renderer.prototype.destroy = function() { 
     56            g_Destroy = true; 
     57        } 
     58         
     59        var r = new OpenLayers.Renderer.SVG(document.body); 
     60        r.clear = function() { 
     61            g_Clear = true; 
     62        } 
     63        r.rendererRoot = 'foo'; 
     64        r.root = 'bar'; 
     65        r.xmlns = 'dude'; 
     66         
     67        r.destroy(); 
     68         
     69        t.eq(g_Clear, true, "OpenLayers.Renderer.Elements.clear() called"); 
     70        t.eq(r.rendererRoot, null, "rendererRoot nullified"); 
     71        t.eq(r.root, null, "root nullified"); 
     72        t.eq(r.xmlns, null, "xmlns nullified"); 
     73        t.eq(g_Destroy, true, "OpenLayers.Renderer.destroy() called"); 
     74         
     75        OpenLayers.Renderer.Elements.prototype.initialize = 
     76            OpenLayers.Renderer.Elements.prototype._initialize; 
     77        OpenLayers.Renderer.prototype.destroy =  
     78            OpenLayers.Renderer.prototype._destroy; 
     79    } 
     80     
     81    function test_Elements_clear(t) { 
     82        t.plan(1); 
     83         
     84        OpenLayers.Renderer.Elements.prototype._initialize = 
     85            OpenLayers.Renderer.Elements.prototype.initialize; 
     86         
     87        OpenLayers.Renderer.Elements.prototype.initialize = function() {} 
     88         
     89        var r = new OpenLayers.Renderer.Elements(); 
     90        var element = document.createElement("div"); 
     91        r.root = element; 
     92         
     93        var node = document.createElement("div"); 
     94        element.appendChild(node); 
     95         
     96        r.clear(); 
     97         
     98        t.ok(r.root.childNodes.length == 0, "root is correctly cleared"); 
     99         
     100        OpenLayers.Renderer.Elements.prototype.initialize = 
     101            OpenLayers.Renderer.Elements.prototype._initialize; 
     102    } 
     103     
     104    function test_Elements_drawGeometry(t) { 
     105        t.plan(4); 
     106         
     107        OpenLayers.Renderer.Elements.prototype._initialize = 
     108            OpenLayers.Renderer.Elements.prototype.initialize; 
     109         
     110        OpenLayers.Renderer.Elements.prototype.initialize = function() {}; 
     111         
     112        var r = new OpenLayers.Renderer.Elements(); 
     113         
     114        var element = document.createElement("div"); 
     115        r.root = element; 
     116 
     117        r.nodeFactory = function(gid, nt, g) { 
     118            var element = document.createElement("div"); 
     119            return element; 
     120        } 
     121        var g_Node = null; 
     122        r.drawGeometryNode = function(n, g) { 
     123            g_Node = n; 
     124            return; 
     125        } 
     126        r.getNodeType = function(geometry) { 
     127            return "div"; 
     128        } 
     129        geometry = { 
     130            id: 'foo', 
     131            CLASS_NAME: 'bar' 
     132        }; 
     133        var style = true; 
     134        var featureId = 'dude'; 
     135        r.drawGeometry(geometry, style, featureId); 
     136        t.ok(g_Node.parentNode == r.root, "node is correctly appended to root"); 
     137        t.eq(g_Node._featureId, 'dude', "_featureId is correct"); 
     138        t.ok(g_Node._style, "_style is correct"); 
     139        t.eq(g_Node._geometryClass, 'bar', "_geometryClass is correct"); 
     140         
     141        OpenLayers.Renderer.Elements.prototype.initialize = 
     142            OpenLayers.Renderer.Elements.prototype._initialize; 
     143    } 
     144 
     145    function test_Elements_drawGeometry_2(t) { 
     146        t.plan(9); 
     147         
     148        OpenLayers.Renderer.Elements.prototype._initialize = 
     149            OpenLayers.Renderer.Elements.prototype.initialize; 
     150             
     151        OpenLayers.Renderer.Elements.prototype.initialize = function() {}; 
     152 
     153        var r = new OpenLayers.Renderer.Elements(); 
     154         
     155        var element = document.createElement("div"); 
     156        r.root = element; 
     157         
     158        r.nodeFactory = function(gid, nt, g) { 
     159            var element = document.createElement("div"); 
     160            return element; 
     161        } 
     162        r.setStyle = function() {}; 
     163         
     164        // point 
     165        var properDraw = false; 
     166        r.drawPoint = function(node, geometry) { 
     167            properDraw = true; 
     168            node = node; 
     169            return {}; 
     170        } 
     171        geometry = {CLASS_NAME: 'OpenLayers.Geometry.Point'}; 
     172        style = true; 
     173        r.drawGeometry(geometry, style); 
     174        t.ok(properDraw, "drawGeometry called drawPoint when passed a point"); 
     175 
     176        // line string 
     177        var properDraw = false; 
     178        r.drawLineString = function(g) { 
     179            properDraw = true; 
     180            return {}; 
     181        } 
     182        geometry = {CLASS_NAME: 'OpenLayers.Geometry.LineString'}; 
     183        style = true; 
     184        r.drawGeometry(geometry, style); 
     185        t.ok(properDraw, "drawGeometry called drawLineString when passed a line string"); 
     186 
     187        // linear ring 
     188        var properDraw = false; 
     189        r.drawLinearRing = function(g) { 
     190            properDraw = true; 
     191            return {}; 
     192        } 
     193        geometry = {CLASS_NAME: 'OpenLayers.Geometry.LinearRing'}; 
     194        style = true; 
     195        r.drawGeometry(geometry, style); 
     196        t.ok(properDraw, "drawGeometry called drawLinearRing when passed a linear ring"); 
     197 
     198        // polygon 
     199        var properDraw = false; 
     200        r.drawPolygon = function(g) { 
     201            properDraw = true; 
     202            return {}; 
     203        } 
     204        geometry = {CLASS_NAME: 'OpenLayers.Geometry.Polygon'}; 
     205        style = true; 
     206        r.drawGeometry(geometry, style); 
     207        t.ok(properDraw, "drawGeometry called drawPolygon when passed a polygon"); 
     208 
     209        // surface 
     210        var properDraw = false; 
     211        r.drawSurface = function(g) { 
     212            properDraw = true; 
     213            return {}; 
     214        } 
     215        geometry = {CLASS_NAME: 'OpenLayers.Geometry.Surface'}; 
     216        style = true; 
     217        r.drawGeometry(geometry, style); 
     218        t.ok(properDraw, "drawGeometry called drawSurface when passed a surface"); 
     219 
     220        // rectangle 
     221        var properDraw = false; 
     222        r.drawRectangle = function(g) { 
     223            properDraw = true; 
     224            return {}; 
     225        } 
     226        geometry = {CLASS_NAME: 'OpenLayers.Geometry.Rectangle'}; 
     227        style = true; 
     228        r.drawGeometry(geometry, style); 
     229        t.ok(properDraw, "drawGeometry called drawRectangle when passed a rectangle"); 
     230 
     231        // multi-point 
     232        var properDraw = false; 
     233        r.drawPoint = function(g) { 
     234            properDraw = true; 
     235            return {}; 
     236        } 
     237        geometry = { 
     238            CLASS_NAME: 'OpenLayers.Geometry.MultiPoint', 
     239            components: [{CLASS_NAME: 'OpenLayers.Geometry.Point'}] 
     240        }; 
     241        style = true; 
     242        r.drawGeometry(geometry, style); 
     243        t.ok(properDraw, "drawGeometry called drawPoint when passed a multi-point"); 
     244 
     245        // multi-linestring 
     246        var properDraw = false; 
     247        r.drawLineString = function(g) { 
     248            properDraw = true; 
     249            return {}; 
     250        } 
     251        geometry = { 
     252            CLASS_NAME: 'OpenLayers.Geometry.MultiLineString', 
     253            components: [{CLASS_NAME: 'OpenLayers.Geometry.LineString'}] 
     254        }; 
     255        style = true; 
     256        r.drawGeometry(geometry, style); 
     257        t.ok(properDraw, "drawGeometry called drawLineString when passed a multi-linestring"); 
     258 
     259        // multi-polygon 
     260        var properDraw = false; 
     261        r.drawPolygon = function(g) { 
     262            properDraw = true; 
     263            return {}; 
     264        } 
     265        geometry = { 
     266            CLASS_NAME: 'OpenLayers.Geometry.MultiPolygon', 
     267            components: [{CLASS_NAME: 'OpenLayers.Geometry.Polygon'}] 
     268        }; 
     269        style = true; 
     270        r.drawGeometry(geometry, style); 
     271        t.ok(properDraw, "drawGeometry called drawPolygon when passed a multi-polygon"); 
     272         
     273        OpenLayers.Renderer.Elements.prototype.initialize = 
     274            OpenLayers.Renderer.Elements.prototype._initialize; 
     275    } 
     276     
     277    function test_Elements_getfeatureidfromevent(t) { 
     278        t.plan(2); 
     279         
     280        var node = { 
     281            _featureId: 'foo' 
     282        } 
     283        var event = { 
     284            target: node 
     285        } 
     286         
     287        var id = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent(event); 
     288        t.eq(id, 'foo', "returned id is correct when event with target is passed"); 
     289         
     290        var event = { 
     291            srcElement: node 
     292        } 
     293         
     294        var id = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent(event); 
     295        t.eq(id, 'foo', "returned id is correct when event with srcElement is passed"); 
     296    } 
     297     
     298    function test_Elements_erasegeometry(t) { 
     299        t.plan(4); 
     300         
     301        var el = document.createElement('div'); 
     302        document.body.appendChild(el); 
     303        el.id = 'foo'; 
     304        var geometry = { 
     305            id: 'foo' 
     306        }; 
     307         
     308        OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
     309        t.ok(el.parentNode != document.body, "element correctly removed"); 
     310 
     311 
     312        var el = document.createElement('div'); 
     313        document.body.appendChild(el); 
     314        el.id = 'foo'; 
     315        var geometry = { 
     316            CLASS_NAME: "OpenLayers.Geometry.MultiPoint", 
     317            components: [{ 
     318                id: 'foo' 
     319            }] 
     320        }; 
     321 
     322        OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
     323        t.ok(el.parentNode != document.body, "geometry components correctly removed when passed a multipoint"); 
     324         
     325        var el = document.createElement('div'); 
     326        document.body.appendChild(el); 
     327        el.id = 'foo'; 
     328        var geometry = { 
     329            CLASS_NAME: "OpenLayers.Geometry.MultiLineString", 
     330            components: [{ 
     331                id: 'foo' 
     332            }] 
     333        }; 
     334         
     335        OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
     336        t.ok(el.parentNode != document.body, "geometry components correctly removed when passed a multilinestring"); 
     337         
     338        var el = document.createElement('div'); 
     339        document.body.appendChild(el); 
     340        el.id = 'foo'; 
     341        var geometry = { 
     342            CLASS_NAME: "OpenLayers.Geometry.MultiPolygon", 
     343            components: [{ 
     344                id: 'foo' 
     345            }] 
     346        }; 
     347         
     348        OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
     349        t.ok(el.parentNode != document.body, "geometry components correctly removed when passed a multipolygon"); 
     350    }     
     351 
     352