OpenLayers OpenLayers

Ticket #1184: patch-1184-r5324-B0.diff

File patch-1184-r5324-B0.diff, 38.5 kB (added by elemoine, 1 year ago)

new patch adapted to Andreas' patch for #1172 (commited in r5323)

  • tests/Renderer/test_Elements.html

    old new  
    114114        var element = document.createElement("div"); 
    115115        r.root = element; 
    116116 
    117         r.nodeFactory = function(gid, nt, g) { 
     117        r.nodeFactory = function(id, type) { 
    118118            var element = document.createElement("div"); 
    119119            return element; 
    120120        } 
    121121        var g_Node = null; 
    122         r.drawGeometryNode = function(n, g) { 
    123             g_Node = n; 
    124             return; 
     122        r.drawGeometryNode = function(node, geometry, style) { 
     123            g_Node = node; 
     124            return node; 
    125125        } 
    126         r.getNodeType = function(geometry) { 
     126        r.getNodeType = function(geometry, style) { 
    127127            return "div"; 
    128128        } 
    129129        geometry = { 
    …… 
    155155        var element = document.createElement("div"); 
    156156        r.root = element; 
    157157         
    158         r.nodeFactory = function(gid, nt, g) { 
     158        r.nodeFactory = function(id, type) { 
    159159            var element = document.createElement("div"); 
    160160            return element; 
    161161        } 
    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'}] 
     162        r.setStyle = function(node, style, options, geometry) { 
     163            return node; 
    240164        }; 
    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"); 
    272165         
    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   </script> 
    353 </head> 
    354 <body> 
    355 <div id="map" style="width:500px;height:550px"></div> 
    356 </body> 
    357 </html> 
    358 <html> 
    359 <head> 
    360 <script src="../../lib/OpenLayers.js"></script> 
    361   <script type="text/javascript"> 
    362  
    363     function test_Elements_constructor(t) { 
    364         t.plan(5); 
    365         var el = document.body; 
    366         el.id = "foo"; 
    367          
    368         OpenLayers.Renderer.Elements.prototype._createRenderRoot = 
    369             OpenLayers.Renderer.Elements.prototype.createRenderRoot; 
    370          
    371         var rendererRoot = document.createElement("div"); 
    372         OpenLayers.Renderer.Elements.prototype.createRenderRoot = function() { 
    373             return rendererRoot; 
    374         } 
    375          
    376         OpenLayers.Renderer.Elements.prototype._createRoot = 
    377             OpenLayers.Renderer.Elements.prototype.createRoot; 
    378          
    379         var root = document.createElement("div"); 
    380         OpenLayers.Renderer.Elements.prototype.createRoot = function() { 
    381             return root; 
    382         } 
    383          
    384         var r = new OpenLayers.Renderer.Elements("foo"); 
    385          
    386         t.ok(r instanceof OpenLayers.Renderer.Elements, "new OpenLayers.Renderer.Elements returns Elements object" ); 
    387         t.ok(r.rendererRoot != null, "elements rendererRoot is not null"); 
    388         t.ok(r.root != null, "elements root is not null"); 
    389          
    390         t.ok(r.root.parentNode == rendererRoot, "elements root is correctly appended to rendererRoot"); 
    391         t.ok(r.rendererRoot.parentNode == document.body, "elements rendererRoot is correctly appended to container"); 
    392          
    393         OpenLayers.Renderer.Elements.prototype.createRenderRoot = 
    394             OpenLayers.Renderer.Elements.prototype._createRenderRoot; 
    395         OpenLayers.Renderer.Elements.prototype.createRoot = 
    396             OpenLayers.Renderer.Elements.prototype._createRoot; 
    397     } 
    398      
    399     function test_Elements_destroy(t) { 
    400         t.plan(5); 
    401          
    402         OpenLayers.Renderer.Elements.prototype._initialize = 
    403             OpenLayers.Renderer.Elements.prototype.initialize; 
    404          
    405         OpenLayers.Renderer.Elements.prototype.initialize = function() {} 
    406          
    407         var g_Clear = false, g_Destroy = false; 
    408          
    409         OpenLayers.Renderer.prototype._destroy =  
    410             OpenLayers.Renderer.prototype.destroy; 
    411              
    412         OpenLayers.Renderer.prototype.destroy = function() { 
    413             g_Destroy = true; 
    414         } 
    415          
    416         var r = new OpenLayers.Renderer.SVG(document.body); 
    417         r.clear = function() { 
    418             g_Clear = true; 
    419         } 
    420         r.rendererRoot = 'foo'; 
    421         r.root = 'bar'; 
    422         r.xmlns = 'dude'; 
    423          
    424         r.destroy(); 
    425          
    426         t.eq(g_Clear, true, "OpenLayers.Renderer.Elements.clear() called"); 
    427         t.eq(r.rendererRoot, null, "rendererRoot nullified"); 
    428         t.eq(r.root, null, "root nullified"); 
    429         t.eq(r.xmlns, null, "xmlns nullified"); 
    430         t.eq(g_Destroy, true, "OpenLayers.Renderer.destroy() called"); 
    431          
    432         OpenLayers.Renderer.Elements.prototype.initialize = 
    433             OpenLayers.Renderer.Elements.prototype._initialize; 
    434         OpenLayers.Renderer.prototype.destroy =  
    435             OpenLayers.Renderer.prototype._destroy; 
    436     } 
    437      
    438     function test_Elements_clear(t) { 
    439         t.plan(1); 
    440          
    441         OpenLayers.Renderer.Elements.prototype._initialize = 
    442             OpenLayers.Renderer.Elements.prototype.initialize; 
    443          
    444         OpenLayers.Renderer.Elements.prototype.initialize = function() {} 
    445          
    446         var r = new OpenLayers.Renderer.Elements(); 
    447         var element = document.createElement("div"); 
    448         r.root = element; 
    449          
    450         var node = document.createElement("div"); 
    451         element.appendChild(node); 
    452          
    453         r.clear(); 
    454          
    455         t.ok(r.root.childNodes.length == 0, "root is correctly cleared"); 
    456          
    457         OpenLayers.Renderer.Elements.prototype.initialize = 
    458             OpenLayers.Renderer.Elements.prototype._initialize; 
    459     } 
    460      
    461     function test_Elements_drawGeometry(t) { 
    462         t.plan(4); 
    463          
    464         OpenLayers.Renderer.Elements.prototype._initialize = 
    465             OpenLayers.Renderer.Elements.prototype.initialize; 
    466          
    467         OpenLayers.Renderer.Elements.prototype.initialize = function() {}; 
    468          
    469         var r = new OpenLayers.Renderer.Elements(); 
    470          
    471         var element = document.createElement("div"); 
    472         r.root = element; 
    473  
    474         r.nodeFactory = function(gid, nt, g) { 
    475             var element = document.createElement("div"); 
    476             return element; 
    477         } 
    478         var g_Node = null; 
    479         r.drawGeometryNode = function(n, g) { 
    480             g_Node = n; 
    481             return; 
    482         } 
    483         r.getNodeType = function(geometry) { 
    484             return "div"; 
    485         } 
    486         geometry = { 
    487             id: 'foo', 
    488             CLASS_NAME: 'bar' 
    489         }; 
    490         var style = true; 
    491         var featureId = 'dude'; 
    492         r.drawGeometry(geometry, style, featureId); 
    493         t.ok(g_Node.parentNode == r.root, "node is correctly appended to root"); 
    494         t.eq(g_Node._featureId, 'dude', "_featureId is correct"); 
    495         t.ok(g_Node._style, "_style is correct"); 
    496         t.eq(g_Node._geometryClass, 'bar', "_geometryClass is correct"); 
    497          
    498         OpenLayers.Renderer.Elements.prototype.initialize = 
    499             OpenLayers.Renderer.Elements.prototype._initialize; 
    500     } 
    501  
    502     function test_Elements_drawGeometry_2(t) { 
    503         t.plan(9); 
    504          
    505         OpenLayers.Renderer.Elements.prototype._initialize = 
    506             OpenLayers.Renderer.Elements.prototype.initialize; 
    507              
    508         OpenLayers.Renderer.Elements.prototype.initialize = function() {}; 
    509  
    510         var r = new OpenLayers.Renderer.Elements(); 
    511          
    512         var element = document.createElement("div"); 
    513         r.root = element; 
    514          
    515         r.nodeFactory = function(gid, nt, g) { 
    516             var element = document.createElement("div"); 
    517             return element; 
    518         } 
    519         r.setStyle = function() {}; 
    520          
    521166        // point 
    522167        var properDraw = false; 
    523168        r.drawPoint = function(node, geometry) { 
    524169            properDraw = true; 
    525             node = node; 
    526170            return {}; 
    527171        } 
    528172        geometry = {CLASS_NAME: 'OpenLayers.Geometry.Point'}; 
    …… 
    712356<div id="map" style="width:500px;height:550px"></div> 
    713357</body> 
    714358</html> 
    715 <html> 
    716 <head> 
    717 <script src="../../lib/OpenLayers.js"></script> 
    718   <script type="text/javascript"> 
    719  
    720     function test_Elements_constructor(t) { 
    721         t.plan(5); 
    722         var el = document.body; 
    723         el.id = "foo"; 
    724          
    725         OpenLayers.Renderer.Elements.prototype._createRenderRoot = 
    726             OpenLayers.Renderer.Elements.prototype.createRenderRoot; 
    727          
    728         var rendererRoot = document.createElement("div"); 
    729         OpenLayers.Renderer.Elements.prototype.createRenderRoot = function() { 
    730             return rendererRoot; 
    731         } 
    732          
    733         OpenLayers.Renderer.Elements.prototype._createRoot = 
    734             OpenLayers.Renderer.Elements.prototype.createRoot; 
    735          
    736         var root = document.createElement("div"); 
    737         OpenLayers.Renderer.Elements.prototype.createRoot = function() { 
    738             return root; 
    739         } 
    740          
    741         var r = new OpenLayers.Renderer.Elements("foo"); 
    742          
    743         t.ok(r instanceof OpenLayers.Renderer.Elements, "new OpenLayers.Renderer.Elements returns Elements object" ); 
    744         t.ok(r.rendererRoot != null, "elements rendererRoot is not null"); 
    745         t.ok(r.root != null, "elements root is not null"); 
    746          
    747         t.ok(r.root.parentNode == rendererRoot, "elements root is correctly appended to rendererRoot"); 
    748         t.ok(r.rendererRoot.parentNode == document.body, "elements rendererRoot is correctly appended to container"); 
    749          
    750         OpenLayers.Renderer.Elements.prototype.createRenderRoot = 
    751             OpenLayers.Renderer.Elements.prototype._createRenderRoot; 
    752         OpenLayers.Renderer.Elements.prototype.createRoot = 
    753             OpenLayers.Renderer.Elements.prototype._createRoot; 
    754     } 
    755      
    756     function test_Elements_destroy(t) { 
    757         t.plan(5); 
    758          
    759         OpenLayers.Renderer.Elements.prototype._initialize = 
    760             OpenLayers.Renderer.Elements.prototype.initialize; 
    761          
    762         OpenLayers.Renderer.Elements.prototype.initialize = function() {} 
    763          
    764         var g_Clear = false, g_Destroy = false; 
    765          
    766         OpenLayers.Renderer.prototype._destroy =  
    767             OpenLayers.Renderer.prototype.destroy; 
    768              
    769         OpenLayers.Renderer.prototype.destroy = function() { 
    770             g_Destroy = true; 
    771         } 
    772          
    773         var r = new OpenLayers.Renderer.SVG(document.body); 
    774         r.clear = function() { 
    775             g_Clear = true; 
    776         } 
    777         r.rendererRoot = 'foo'; 
    778         r.root = 'bar'; 
    779         r.xmlns = 'dude'; 
    780          
    781         r.destroy(); 
    782          
    783         t.eq(g_Clear, true, "OpenLayers.Renderer.Elements.clear() called"); 
    784         t.eq(r.rendererRoot, null, "rendererRoot nullified"); 
    785         t.eq(r.root, null, "root nullified"); 
    786         t.eq(r.xmlns, null, "xmlns nullified"); 
    787         t.eq(g_Destroy, true, "OpenLayers.Renderer.destroy() called"); 
    788          
    789         OpenLayers.Renderer.Elements.prototype.initialize = 
    790             OpenLayers.Renderer.Elements.prototype._initialize; 
    791         OpenLayers.Renderer.prototype.destroy =  
    792             OpenLayers.Renderer.prototype._destroy; 
    793     } 
    794      
    795     function test_Elements_clear(t) { 
    796         t.plan(1); 
    797          
    798         OpenLayers.Renderer.Elements.prototype._initialize = 
    799             OpenLayers.Renderer.Elements.prototype.initialize; 
    800          
    801         OpenLayers.Renderer.Elements.prototype.initialize = function() {} 
    802          
    803         var r = new OpenLayers.Renderer.Elements(); 
    804         var element = document.createElement("div"); 
    805         r.root = element; 
    806          
    807         var node = document.createElement("div"); 
    808         element.appendChild(node); 
    809          
    810         r.clear(); 
    811          
    812         t.ok(r.root.childNodes.length == 0, "root is correctly cleared"); 
    813          
    814         OpenLayers.Renderer.Elements.prototype.initialize = 
    815             OpenLayers.Renderer.Elements.prototype._initialize; 
    816     } 
    817      
    818     function test_Elements_drawGeometry(t) { 
    819         t.plan(4); 
    820          
    821         OpenLayers.Renderer.Elements.prototype._initialize = 
    822             OpenLayers.Renderer.Elements.prototype.initialize; 
    823          
    824         OpenLayers.Renderer.Elements.prototype.initialize = function() {}; 
    825          
    826         var r = new OpenLayers.Renderer.Elements(); 
    827          
    828         var element = document.createElement("div"); 
    829         r.root = element; 
    830  
    831         r.nodeFactory = function(gid, nt, g) { 
    832             var element = document.createElement("div"); 
    833             return element; 
    834         } 
    835         var g_Node = null; 
    836         r.drawGeometryNode = function(n, g) { 
    837             g_Node = n; 
    838             return; 
    839         } 
    840         r.getNodeType = function(geometry) { 
    841             return "div"; 
    842         } 
    843         geometry = { 
    844             id: 'foo', 
    845             CLASS_NAME: 'bar' 
    846         }; 
    847         var style = true; 
    848         var featureId = 'dude'; 
    849         r.drawGeometry(geometry, style, featureId); 
    850         t.ok(g_Node.parentNode == r.root, "node is correctly appended to root"); 
    851         t.eq(g_Node._featureId, 'dude', "_featureId is correct"); 
    852         t.ok(g_Node._style, "_style is correct"); 
    853         t.eq(g_Node._geometryClass, 'bar', "_geometryClass is correct"); 
    854          
    855         OpenLayers.Renderer.Elements.prototype.initialize = 
    856             OpenLayers.Renderer.Elements.prototype._initialize; 
    857     } 
    858  
    859     function test_Elements_drawGeometry_2(t) { 
    860         t.plan(9); 
    861          
    862         OpenLayers.Renderer.Elements.prototype._initialize = 
    863             OpenLayers.Renderer.Elements.prototype.initialize; 
    864              
    865         OpenLayers.Renderer.Elements.prototype.initialize = function() {}; 
    866  
    867         var r = new OpenLayers.Renderer.Elements(); 
    868          
    869         var element = document.createElement("div"); 
    870         r.root = element; 
    871          
    872         r.nodeFactory = function(gid, nt, g) { 
    873             var element = document.createElement("div"); 
    874             return element; 
    875         } 
    876         r.setStyle = function() {}; 
    877          
    878         // point 
    879         var properDraw = false; 
    880         r.drawPoint = function(node, geometry) { 
    881             properDraw = true; 
    882             node = node; 
    883             return {}; 
    884         } 
    885         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Point'}; 
    886         style = true; 
    887         r.drawGeometry(geometry, style); 
    888         t.ok(properDraw, "drawGeometry called drawPoint when passed a point"); 
    889  
    890         // line string 
    891         var properDraw = false; 
    892         r.drawLineString = function(g) { 
    893             properDraw = true; 
    894             return {}; 
    895         } 
    896         geometry = {CLASS_NAME: 'OpenLayers.Geometry.LineString'}; 
    897         style = true; 
    898         r.drawGeometry(geometry, style); 
    899         t.ok(properDraw, "drawGeometry called drawLineString when passed a line string"); 
    900  
    901         // linear ring 
    902         var properDraw = false; 
    903         r.drawLinearRing = function(g) { 
    904             properDraw = true; 
    905             return {}; 
    906         } 
    907         geometry = {CLASS_NAME: 'OpenLayers.Geometry.LinearRing'}; 
    908         style = true; 
    909         r.drawGeometry(geometry, style); 
    910         t.ok(properDraw, "drawGeometry called drawLinearRing when passed a linear ring"); 
    911  
    912         // polygon 
    913         var properDraw = false; 
    914         r.drawPolygon = function(g) { 
    915             properDraw = true; 
    916             return {}; 
    917         } 
    918         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Polygon'}; 
    919         style = true; 
    920         r.drawGeometry(geometry, style); 
    921         t.ok(properDraw, "drawGeometry called drawPolygon when passed a polygon"); 
    922  
    923         // surface 
    924         var properDraw = false; 
    925         r.drawSurface = function(g) { 
    926             properDraw = true; 
    927             return {}; 
    928         } 
    929         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Surface'}; 
    930         style = true; 
    931         r.drawGeometry(geometry, style); 
    932         t.ok(properDraw, "drawGeometry called drawSurface when passed a surface"); 
    933  
    934         // rectangle 
    935         var properDraw = false; 
    936         r.drawRectangle = function(g) { 
    937             properDraw = true; 
    938             return {}; 
    939         } 
    940         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Rectangle'}; 
    941         style = true; 
    942         r.drawGeometry(geometry, style); 
    943         t.ok(properDraw, "drawGeometry called drawRectangle when passed a rectangle"); 
    944  
    945         // multi-point 
    946         var properDraw = false; 
    947         r.drawPoint = function(g) { 
    948             properDraw = true; 
    949             return {}; 
    950         } 
    951         geometry = { 
    952             CLASS_NAME: 'OpenLayers.Geometry.MultiPoint', 
    953             components: [{CLASS_NAME: 'OpenLayers.Geometry.Point'}] 
    954         }; 
    955         style = true; 
    956         r.drawGeometry(geometry, style); 
    957         t.ok(properDraw, "drawGeometry called drawPoint when passed a multi-point"); 
    958  
    959         // multi-linestring 
    960         var properDraw = false; 
    961         r.drawLineString = function(g) { 
    962             properDraw = true; 
    963             return {}; 
    964         } 
    965         geometry = { 
    966             CLASS_NAME: 'OpenLayers.Geometry.MultiLineString', 
    967             components: [{CLASS_NAME: 'OpenLayers.Geometry.LineString'}] 
    968         }; 
    969         style = true; 
    970         r.drawGeometry(geometry, style); 
    971         t.ok(properDraw, "drawGeometry called drawLineString when passed a multi-linestring"); 
    972  
    973         // multi-polygon 
    974         var properDraw = false; 
    975         r.drawPolygon = function(g) { 
    976             properDraw = true; 
    977             return {}; 
    978         } 
    979         geometry = { 
    980             CLASS_NAME: 'OpenLayers.Geometry.MultiPolygon', 
    981             components: [{CLASS_NAME: 'OpenLayers.Geometry.Polygon'}] 
    982         }; 
    983         style = true; 
    984         r.drawGeometry(geometry, style); 
    985         t.ok(properDraw, "drawGeometry called drawPolygon when passed a multi-polygon"); 
    986          
    987         OpenLayers.Renderer.Elements.prototype.initialize = 
    988             OpenLayers.Renderer.Elements.prototype._initialize; 
    989     } 
    990      
    991     function test_Elements_getfeatureidfromevent(t) { 
    992         t.plan(2); 
    993          
    994         var node = { 
    995             _featureId: 'foo' 
    996         } 
    997         var event = { 
    998             target: node 
    999         } 
    1000          
    1001         var id = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent(event); 
    1002         t.eq(id, 'foo', "returned id is correct when event with target is passed"); 
    1003          
    1004         var event = { 
    1005             srcElement: node 
    1006         } 
    1007          
    1008         var id = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent(event); 
    1009         t.eq(id, 'foo', "returned id is correct when event with srcElement is passed"); 
    1010     } 
    1011      
    1012     function test_Elements_erasegeometry(t) { 
    1013         t.plan(4); 
    1014          
    1015         var el = document.createElement('div'); 
    1016         document.body.appendChild(el); 
    1017         el.id = 'foo'; 
    1018         var geometry = { 
    1019             id: 'foo' 
    1020         }; 
    1021          
    1022         OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
    1023         t.ok(el.parentNode != document.body, "element correctly removed"); 
    1024  
    1025  
    1026         var el = document.createElement('div'); 
    1027         document.body.appendChild(el); 
    1028         el.id = 'foo'; 
    1029         var geometry = { 
    1030             CLASS_NAME: "OpenLayers.Geometry.MultiPoint", 
    1031             components: [{ 
    1032                 id: 'foo' 
    1033             }] 
    1034         }; 
    1035  
    1036         OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
    1037         t.ok(el.parentNode != document.body, "geometry components correctly removed when passed a multipoint"); 
    1038          
    1039         var el = document.createElement('div'); 
    1040         document.body.appendChild(el); 
    1041         el.id = 'foo'; 
    1042         var geometry = { 
    1043             CLASS_NAME: "OpenLayers.Geometry.MultiLineString", 
    1044             components: [{ 
    1045                 id: 'foo' 
    1046             }] 
    1047         }; 
    1048          
    1049         OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
    1050         t.ok(el.parentNode != document.body, "geometry components correctly removed when passed a multilinestring"); 
    1051          
    1052         var el = document.createElement('div'); 
    1053         document.body.appendChild(el); 
    1054         el.id = 'foo'; 
    1055         var geometry = { 
    1056             CLASS_NAME: "OpenLayers.Geometry.MultiPolygon", 
    1057             components: [{ 
    1058                 id: 'foo' 
    1059             }] 
    1060         }; 
    1061          
    1062         OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
    1063         t.ok(el.parentNode != document.body, "geometry components correctly removed when passed a multipolygon"); 
    1064     }     
    1065  
    1066   </script> 
    1067 </head> 
    1068 <body> 
    1069 <div id="map" style="width:500px;height:550px"></div> 
    1070 </body> 
    1071 </html> 
    1072 <html> 
    1073 <head> 
    1074 <script src="../../lib/OpenLayers.js"></script> 
    1075   <script type="text/javascript"> 
    1076  
    1077     function test_Elements_constructor(t) { 
    1078         t.plan(5); 
    1079         var el = document.body; 
    1080         el.id = "foo"; 
    1081          
    1082         OpenLayers.Renderer.Elements.prototype._createRenderRoot = 
    1083             OpenLayers.Renderer.Elements.prototype.createRenderRoot; 
    1084          
    1085         var rendererRoot = document.createElement("div"); 
    1086         OpenLayers.Renderer.Elements.prototype.createRenderRoot = function() { 
    1087             return rendererRoot; 
    1088         } 
    1089          
    1090         OpenLayers.Renderer.Elements.prototype._createRoot = 
    1091             OpenLayers.Renderer.Elements.prototype.createRoot; 
    1092          
    1093         var root = document.createElement("div"); 
    1094         OpenLayers.Renderer.Elements.prototype.createRoot = function() { 
    1095             return root; 
    1096         } 
    1097          
    1098         var r = new OpenLayers.Renderer.Elements("foo"); 
    1099          
    1100         t.ok(r instanceof OpenLayers.Renderer.Elements, "new OpenLayers.Renderer.Elements returns Elements object" ); 
    1101         t.ok(r.rendererRoot != null, "elements rendererRoot is not null"); 
    1102         t.ok(r.root != null, "elements root is not null"); 
    1103          
    1104         t.ok(r.root.parentNode == rendererRoot, "elements root is correctly appended to rendererRoot"); 
    1105         t.ok(r.rendererRoot.parentNode == document.body, "elements rendererRoot is correctly appended to container"); 
    1106          
    1107         OpenLayers.Renderer.Elements.prototype.createRenderRoot = 
    1108             OpenLayers.Renderer.Elements.prototype._createRenderRoot; 
    1109         OpenLayers.Renderer.Elements.prototype.createRoot = 
    1110             OpenLayers.Renderer.Elements.prototype._createRoot; 
    1111     } 
    1112      
    1113     function test_Elements_destroy(t) { 
    1114         t.plan(5); 
    1115          
    1116         OpenLayers.Renderer.Elements.prototype._initialize = 
    1117             OpenLayers.Renderer.Elements.prototype.initialize; 
    1118          
    1119         OpenLayers.Renderer.Elements.prototype.initialize = function() {} 
    1120          
    1121         var g_Clear = false, g_Destroy = false; 
    1122          
    1123         OpenLayers.Renderer.prototype._destroy =  
    1124             OpenLayers.Renderer.prototype.destroy; 
    1125              
    1126         OpenLayers.Renderer.prototype.destroy = function() { 
    1127             g_Destroy = true; 
    1128         } 
    1129          
    1130         var r = new OpenLayers.Renderer.SVG(document.body); 
    1131         r.clear = function() { 
    1132             g_Clear = true; 
    1133         } 
    1134         r.rendererRoot = 'foo'; 
    1135         r.root = 'bar'; 
    1136         r.xmlns = 'dude'; 
    1137          
    1138         r.destroy(); 
    1139          
    1140         t.eq(g_Clear, true, "OpenLayers.Renderer.Elements.clear() called"); 
    1141         t.eq(r.rendererRoot, null, "rendererRoot nullified"); 
    1142         t.eq(r.root, null, "root nullified"); 
    1143         t.eq(r.xmlns, null, "xmlns nullified"); 
    1144         t.eq(g_Destroy, true, "OpenLayers.Renderer.destroy() called"); 
    1145          
    1146         OpenLayers.Renderer.Elements.prototype.initialize = 
    1147             OpenLayers.Renderer.Elements.prototype._initialize; 
    1148         OpenLayers.Renderer.prototype.destroy =  
    1149             OpenLayers.Renderer.prototype._destroy; 
    1150     } 
    1151      
    1152     function test_Elements_clear(t) { 
    1153         t.plan(1); 
    1154          
    1155         OpenLayers.Renderer.Elements.prototype._initialize = 
    1156             OpenLayers.Renderer.Elements.prototype.initialize; 
    1157          
    1158         OpenLayers.Renderer.Elements.prototype.initialize = function() {} 
    1159          
    1160         var r = new OpenLayers.Renderer.Elements(); 
    1161         var element = document.createElement("div"); 
    1162         r.root = element; 
    1163          
    1164         var node = document.createElement("div"); 
    1165         element.appendChild(node); 
    1166          
    1167         r.clear(); 
    1168          
    1169         t.ok(r.root.childNodes.length == 0, "root is correctly cleared"); 
    1170          
    1171         OpenLayers.Renderer.Elements.prototype.initialize = 
    1172             OpenLayers.Renderer.Elements.prototype._initialize; 
    1173     } 
    1174      
    1175     function test_Elements_drawGeometry(t) { 
    1176         t.plan(4); 
    1177          
    1178         OpenLayers.Renderer.Elements.prototype._initialize = 
    1179             OpenLayers.Renderer.Elements.prototype.initialize; 
    1180          
    1181         OpenLayers.Renderer.Elements.prototype.initialize = function() {}; 
    1182          
    1183         var r = new OpenLayers.Renderer.Elements(); 
    1184          
    1185         var element = document.createElement("div"); 
    1186         r.root = element; 
    1187  
    1188         r.nodeFactory = function(gid, nt, g) { 
    1189             var element = document.createElement("div"); 
    1190             return element; 
    1191         } 
    1192         var g_Node = null; 
    1193         r.drawGeometryNode = function(n, g) { 
    1194             g_Node = n; 
    1195             return; 
    1196         } 
    1197         r.getNodeType = function(geometry) { 
    1198             return "div"; 
    1199         } 
    1200         geometry = { 
    1201             id: 'foo', 
    1202             CLASS_NAME: 'bar' 
    1203         }; 
    1204         var style = true; 
    1205         var featureId = 'dude'; 
    1206         r.drawGeometry(geometry, style, featureId); 
    1207         t.ok(g_Node.parentNode == r.root, "node is correctly appended to root"); 
    1208         t.eq(g_Node._featureId, 'dude', "_featureId is correct"); 
    1209         t.ok(g_Node._style, "_style is correct"); 
    1210         t.eq(g_Node._geometryClass, 'bar', "_geometryClass is correct"); 
    1211          
    1212         OpenLayers.Renderer.Elements.prototype.initialize = 
    1213             OpenLayers.Renderer.Elements.prototype._initialize; 
    1214     } 
    1215  
    1216     function test_Elements_drawGeometry_2(t) { 
    1217         t.plan(9); 
    1218          
    1219         OpenLayers.Renderer.Elements.prototype._initialize = 
    1220             OpenLayers.Renderer.Elements.prototype.initialize; 
    1221              
    1222         OpenLayers.Renderer.Elements.prototype.initialize = function() {}; 
    1223  
    1224         var r = new OpenLayers.Renderer.Elements(); 
    1225          
    1226         var element = document.createElement("div"); 
    1227         r.root = element; 
    1228          
    1229         r.nodeFactory = function(gid, nt, g) { 
    1230             var element = document.createElement("div"); 
    1231             return element; 
    1232         } 
    1233         r.setStyle = function() {}; 
    1234          
    1235         // point 
    1236         var properDraw = false; 
    1237         r.drawPoint = function(node, geometry) { 
    1238             properDraw = true; 
    1239             node = node; 
    1240             return {}; 
    1241         } 
    1242         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Point'}; 
    1243         style = true; 
    1244         r.drawGeometry(geometry, style); 
    1245         t.ok(properDraw, "drawGeometry called drawPoint when passed a point"); 
    1246  
    1247         // line string 
    1248         var properDraw = false; 
    1249         r.drawLineString = function(g) { 
    1250             properDraw = true; 
    1251             return {}; 
    1252         } 
    1253         geometry = {CLASS_NAME: 'OpenLayers.Geometry.LineString'}; 
    1254         style = true; 
    1255         r.drawGeometry(geometry, style); 
    1256         t.ok(properDraw, "drawGeometry called drawLineString when passed a line string"); 
    1257  
    1258         // linear ring 
    1259         var properDraw = false; 
    1260         r.drawLinearRing = function(g) { 
    1261             properDraw = true; 
    1262             return {}; 
    1263         } 
    1264         geometry = {CLASS_NAME: 'OpenLayers.Geometry.LinearRing'}; 
    1265         style = true; 
    1266         r.drawGeometry(geometry, style); 
    1267         t.ok(properDraw, "drawGeometry called drawLinearRing when passed a linear ring"); 
    1268  
    1269         // polygon 
    1270         var properDraw = false; 
    1271         r.drawPolygon = function(g) { 
    1272             properDraw = true; 
    1273             return {}; 
    1274         } 
    1275         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Polygon'}; 
    1276         style = true; 
    1277         r.drawGeometry(geometry, style); 
    1278         t.ok(properDraw, "drawGeometry called drawPolygon when passed a polygon"); 
    1279  
    1280         // surface 
    1281         var properDraw = false; 
    1282         r.drawSurface = function(g) { 
    1283             properDraw = true; 
    1284             return {}; 
    1285         } 
    1286         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Surface'}; 
    1287         style = true; 
    1288         r.drawGeometry(geometry, style); 
    1289         t.ok(properDraw, "drawGeometry called drawSurface when passed a surface"); 
    1290  
    1291         // rectangle 
    1292         var properDraw = false; 
    1293         r.drawRectangle = function(g) { 
    1294             properDraw = true; 
    1295             return {}; 
    1296         } 
    1297         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Rectangle'}; 
    1298         style = true; 
    1299         r.drawGeometry(geometry, style); 
    1300         t.ok(properDraw, "drawGeometry called drawRectangle when passed a rectangle"); 
    1301  
    1302         // multi-point 
    1303         var properDraw = false; 
    1304         r.drawPoint = function(g) { 
    1305             properDraw = true; 
    1306             return {}; 
    1307         } 
    1308         geometry = { 
    1309             CLASS_NAME: 'OpenLayers.Geometry.MultiPoint', 
    1310             components: [{CLASS_NAME: 'OpenLayers.Geometry.Point'}] 
    1311         }; 
    1312         style = true; 
    1313&n