OpenLayers OpenLayers

Changeset 5329

Show
Ignore:
Timestamp:
12/03/07 03:13:04 (1 year ago)
Author:
elemoine
Message:

fix test_Elements.html tests and make them compatible with r5323 (#1172) (closes #1184)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/openlayers/tests/Renderer/test_Elements.html

    r5320 r5329  
    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; 
    125         } 
    126         r.getNodeType = function(geometry) { 
     122        r.drawGeometryNode = function(node, geometry, style) { 
     123            g_Node = node; 
     124            return node; 
     125        } 
     126        r.getNodeType = function(geometry, style) { 
    127127            return "div"; 
    128128        } 
    …… 
    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() {}; 
     162        r.setStyle = function(node, style, options, geometry) { 
     163            return node; 
     164        }; 
    163165         
    164166        // point 
    …… 
    166168        r.drawPoint = function(node, geometry) { 
    167169            properDraw = true; 
    168             node = node; 
    169170            return {}; 
    170171        } 
    …… 
    356357</body> 
    357358</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          
    521         // point 
    522         var properDraw = false; 
    523         r.drawPoint = function(node, geometry) { 
    524             properDraw = true; 
    525             node = node; 
    526             return {}; 
    527         } 
    528         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Point'}; 
    529         style = true; 
    530         r.drawGeometry(geometry, style); 
    531         t.ok(properDraw, "drawGeometry called drawPoint when passed a point"); 
    532  
    533         // line string 
    534         var properDraw = false; 
    535         r.drawLineString = function(g) { 
    536             properDraw = true; 
    537             return {}; 
    538         } 
    539         geometry = {CLASS_NAME: 'OpenLayers.Geometry.LineString'}; 
    540         style = true; 
    541         r.drawGeometry(geometry, style); 
    542         t.ok(properDraw, "drawGeometry called drawLineString when passed a line string"); 
    543  
    544         // linear ring 
    545         var properDraw = false; 
    546         r.drawLinearRing = function(g) { 
    547             properDraw = true; 
    548             return {}; 
    549         } 
    550         geometry = {CLASS_NAME: 'OpenLayers.Geometry.LinearRing'}; 
    551         style = true; 
    552         r.drawGeometry(geometry, style); 
    553         t.ok(properDraw, "drawGeometry called drawLinearRing when passed a linear ring"); 
    554  
    555         // polygon 
    556         var properDraw = false; 
    557         r.drawPolygon = function(g) { 
    558             properDraw = true; 
    559             return {}; 
    560         } 
    561         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Polygon'}; 
    562         style = true; 
    563         r.drawGeometry(geometry, style); 
    564         t.ok(properDraw, "drawGeometry called drawPolygon when passed a polygon"); 
    565  
    566         // surface 
    567         var properDraw = false; 
    568         r.drawSurface = function(g) { 
    569             properDraw = true; 
    570             return {}; 
    571         } 
    572         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Surface'}; 
    573         style = true; 
    574         r.drawGeometry(geometry, style); 
    575         t.ok(properDraw, "drawGeometry called drawSurface when passed a surface"); 
    576  
    577         // rectangle 
    578         var properDraw = false; 
    579         r.drawRectangle = function(g) { 
    580             properDraw = true; 
    581             return {}; 
    582         } 
    583         geometry = {CLASS_NAME: 'OpenLayers.Geometry.Rectangle'}; 
    584         style = true; 
    585         r.drawGeometry(geometry, style); 
    586         t.ok(properDraw, "drawGeometry called drawRectangle when passed a rectangle"); 
    587  
    588         // multi-point 
    589         var properDraw = false; 
    590         r.drawPoint = function(g) { 
    591             properDraw = true; 
    592             return {}; 
    593         } 
    594         geometry = { 
    595             CLASS_NAME: 'OpenLayers.Geometry.MultiPoint', 
    596             components: [{CLASS_NAME: 'OpenLayers.Geometry.Point'}] 
    597         }; 
    598         style = true; 
    599         r.drawGeometry(geometry, style); 
    600         t.ok(properDraw, "drawGeometry called drawPoint when passed a multi-point"); 
    601  
    602         // multi-linestring 
    603         var properDraw = false; 
    604         r.drawLineString = function(g) { 
    605             properDraw = true; 
    606             return {}; 
    607         } 
    608         geometry = { 
    609             CLASS_NAME: 'OpenLayers.Geometry.MultiLineString', 
    610             components: [{CLASS_NAME: 'OpenLayers.Geometry.LineString'}] 
    611         }; 
    612         style = true; 
    613         r.drawGeometry(geometry, style); 
    614         t.ok(properDraw, "drawGeometry called drawLineString when passed a multi-linestring"); 
    615  
    616         // multi-polygon 
    617         var properDraw = false; 
    618         r.drawPolygon = function(g) { 
    619             properDraw = true; 
    620             return {}; 
    621         } 
    622         geometry = { 
    623             CLASS_NAME: 'OpenLayers.Geometry.MultiPolygon', 
    624             components: [{CLASS_NAME: 'OpenLayers.Geometry.Polygon'}] 
    625         }; 
    626         style = true; 
    627         r.drawGeometry(geometry, style); 
    628         t.ok(properDraw, "drawGeometry called drawPolygon when passed a multi-polygon"); 
    629          
    630         OpenLayers.Renderer.Elements.prototype.initialize = 
    631             OpenLayers.Renderer.Elements.prototype._initialize; 
    632     } 
    633      
    634     function test_Elements_getfeatureidfromevent(t) { 
    635         t.plan(2); 
    636          
    637         var node = { 
    638             _featureId: 'foo' 
    639         } 
    640         var event = { 
    641             target: node 
    642         } 
    643          
    644         var id = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent(event); 
    645         t.eq(id, 'foo', "returned id is correct when event with target is passed"); 
    646          
    647         var event = { 
    648             srcElement: node 
    649         } 
    650          
    651         var id = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent(event); 
    652         t.eq(id, 'foo', "returned id is correct when event with srcElement is passed"); 
    653     } 
    654      
    655     function test_Elements_erasegeometry(t) { 
    656         t.plan(4); 
    657          
    658         var el = document.createElement('div'); 
    659         document.body.appendChild(el); 
    660         el.id = 'foo'; 
    661         var geometry = { 
    662             id: 'foo' 
    663         }; 
    664          
    665         OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
    666         t.ok(el.parentNode != document.body, "element correctly removed"); 
    667  
    668  
    669         var el = document.createElement('div'); 
    670         document.body.appendChild(el); 
    671         el.id = 'foo'; 
    672         var geometry = { 
    673             CLASS_NAME: "OpenLayers.Geometry.MultiPoint", 
    674             components: [{ 
    675                 id: 'foo' 
    676             }] 
    677         }; 
    678  
    679         OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
    680         t.ok(el.parentNode != document.body, "geometry components correctly removed when passed a multipoint"); 
    681          
    682         var el = document.createElement('div'); 
    683         document.body.appendChild(el); 
    684         el.id = 'foo'; 
    685         var geometry = { 
    686             CLASS_NAME: "OpenLayers.Geometry.MultiLineString", 
    687             components: [{ 
    688                 id: 'foo' 
    689             }] 
    690         }; 
    691          
    692         OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
    693         t.ok(el.parentNode != document.body, "geometry components correctly removed when passed a multilinestring"); 
    694          
    695         var el = document.createElement('div'); 
    696         document.body.appendChild(el); 
    697         el.id = 'foo'; 
    698         var geometry = { 
    699             CLASS_NAME: "OpenLayers.Geometry.MultiPolygon", 
    700             components: [{ 
    701                 id: 'foo' 
    702             }] 
    703         }; 
    704          
    705         OpenLayers.Renderer.Elements.prototype.eraseGeometry(geometry); 
    706         t.ok(el.parentNode != document.body, "geometry components correctly removed when passed a multipolygon"); 
    707     }     
    708  
    709   </script> 
    710 </head> 
    711 <body> 
    712 <div id="map" style="width:500px;height:550px"></div> 
    713 </body> 
    714 </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       &n