OpenLayers OpenLayers

Ticket #1128: renderers_tests.3.patch

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

  • tests/Renderer/test_VML.html

    old new  
    302302<body> 
    303303<div id="map" style="width:500px;height:550px"></div> 
    304304</body> 
    305 </html> 
    306 <html> 
    307 <head> 
    308 <script src="../../lib/OpenLayers.js"></script> 
    309   <script type="text/javascript"> 
    310  
    311     var geometry = null, node = null; 
    312  
    313     function test_VML_constructor(t) { 
    314         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    315             t.plan(0); 
    316             return; 
    317         } 
    318          
    319         t.plan(1); 
    320         var r = new OpenLayers.Renderer.VML(document.body); 
    321         t.ok(r instanceof OpenLayers.Renderer.VML, "new OpenLayers.Renderer.VML returns VML object" ); 
    322     } 
    323      
    324     function test_VML_destroy(t) { 
    325         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    326             t.plan(0); 
    327             return; 
    328         } 
    329          
    330         t.plan(1); 
    331          
    332         var g_Destroy = false; 
    333          
    334         OpenLayers.Renderer.Elements.prototype._destroy =  
    335             OpenLayers.Renderer.Elements.prototype.destroy; 
    336              
    337         OpenLayers.Renderer.prototype.destroy = function() { 
    338             g_Destroy = true; 
    339         } 
    340          
    341         var r = new OpenLayers.Renderer.VML(document.body); 
    342         r.destroy(); 
    343          
    344         t.eq(g_Destroy, true, "OpenLayers.Renderer.Elements.destroy() called"); 
    345          
    346         OpenLayers.Renderer.prototype.destroy =  
    347             OpenLayers.Renderer.prototype._destroy; 
    348     } 
    349      
    350     function test_VML_setextent(t) { 
    351         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    352             t.plan(0); 
    353             return; 
    354         } 
    355          
    356         t.plan(3); 
    357          
    358         OpenLayers.Renderer.Elements.prototype._setExtent = 
    359             OpenLayers.Renderer.Elements.prototype.setExtent; 
    360          
    361         var g_SetExtent = false; 
    362         OpenLayers.Renderer.Elements.prototype.setExtent = function() { 
    363             g_SetExtent = true; 
    364         } 
    365                  
    366         var r = new OpenLayers.Renderer.VML(document.body); 
    367         r.map = { 
    368             getResolution: function() { 
    369                 return 0.5; 
    370             } 
    371         } 
    372          
    373         var extent = new OpenLayers.Bounds(1,2,3,4); 
    374         r.setExtent(extent); 
    375          
    376         t.eq(g_SetExtent, true, "Elements.setExtent() called"); 
    377          
    378         t.ok(r.root.coordorigin == "2,8", "coordorigin is correct"); 
    379         t.ok(r.root.coordsize == "4,-4", "coordsize is correct"); 
    380          
    381         OpenLayers.Renderer.Elements.prototype.setExtent = 
    382             OpenLayers.Renderer.Elements.prototype._setExtent; 
    383     } 
    384  
    385     function test_VML_setsize(t) { 
    386         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    387             t.plan(0); 
    388             return; 
    389         } 
    390          
    391         t.plan(4); 
    392                  
    393         var r = new OpenLayers.Renderer.VML(document.body); 
    394          
    395         var size = new OpenLayers.Size(1,2); 
    396         r.setSize(size); 
    397         t.eq(r.rendererRoot.style.width, "1px", "rendererRoot width is correct"); 
    398         t.eq(r.rendererRoot.style.height, "2px", "rendererRoot height is correct"); 
    399          
    400         t.eq(r.root.style.width, "100%", "root width is correct"); 
    401         t.eq(r.root.style.height, "100%", "root height is correct"); 
    402     } 
    403  
    404     function test_VML_drawpoint(t) { 
    405         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    406             t.plan(0); 
    407             return; 
    408         } 
    409      
    410         t.plan(1); 
    411  
    412         var r = new OpenLayers.Renderer.VML(document.body); 
    413          
    414         var properDraw = false; 
    415         var g_Radius = null; 
    416         r.drawCircle = function(n, g, r) { 
    417             properDraw = true; 
    418             g_Radius = 1; 
    419         } 
    420         r.drawPoint(); 
    421          
    422         t.ok(properDraw && g_Radius == 1, "drawPoint called drawCircle with radius set to 1"); 
    423     } 
    424  
    425     function test_VML_drawcircle(t) { 
    426         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    427             t.plan(0); 
    428             return; 
    429         } 
    430          
    431         t.plan(4); 
    432          
    433         var r = new OpenLayers.Renderer.VML(document.body); 
    434         r.resolution = 0.5; 
    435          
    436         var node = document.createElement('div'); 
    437          
    438         var geometry = { 
    439             x: 1, 
    440             y: 2 
    441         } 
    442          
    443         var radius = 3; 
    444         r.drawCircle(node, geometry, radius); 
    445          
    446         t.eq(node.style.left, '-1px', "left is correct"); 
    447         t.eq(node.style.top, '1px', "top is correct"); 
    448         t.eq(node.style.width, (2 * radius) + "px", "width is correct"); 
    449         t.eq(node.style.height, (2 * radius) + "px", "height is correct"); 
    450     } 
    451  
    452     function test_VML_drawlinestring(t) { 
    453         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    454             t.plan(0); 
    455             return; 
    456         } 
    457          
    458         t.plan(1); 
    459          
    460         var r = new OpenLayers.Renderer.VML(document.body); 
    461          
    462         g_DrawLine = false; 
    463         r.drawLine = function(c) { 
    464             g_DrawLine = true; 
    465         } 
    466          
    467         r.drawLineString(node, geometry); 
    468          
    469         t.ok(g_DrawLine, "drawLine is called"); 
    470     } 
    471      
    472     function test_VML_drawlinearring(t) { 
    473         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    474             t.plan(0); 
    475             return; 
    476         } 
    477          
    478         t.plan(1); 
    479          
    480         var r = new OpenLayers.Renderer.VML(document.body); 
    481          
    482         g_DrawLine = false; 
    483         r.drawLine = function(c) { 
    484             g_DrawLine = true; 
    485         } 
    486          
    487         r.drawLinearRing(node, geometry); 
    488          
    489         t.ok(g_DrawLine, "drawLine is called"); 
    490     } 
    491  
    492     function test_VML_drawline(t) { 
    493         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    494             t.plan(0); 
    495             return; 
    496         } 
    497          
    498         t.plan(8); 
    499          
    500         var r = new OpenLayers.Renderer.VML(document.body); 
    501         r.resolution = 0.5; 
    502          
    503         var node = document.createElement('div'); 
    504          
    505         var geometry = { 
    506             components: [{ 
    507                 x: 1, 
    508                 y: 2 
    509             },{ 
    510                 x: 3, 
    511                 y: 4 
    512             }], 
    513             getBounds: function() { 
    514                 return new OpenLayers.Bounds(5,6,7,8); 
    515             } 
    516         }; 
    517          
    518         r.drawLine(node, geometry, true); 
    519         t.ok(node.path.indexOf("x") != -1, "path attribute is correct when passed closeLine = true"); 
    520          
    521          
    522         r.drawLine(node, geometry, false); 
    523         t.eq(node.path, "m 2,4 l  6,8 l  e", "path attribute is correct"); 
    524         t.eq(node.style.left, "10px", "node.style.left is correct"); 
    525         t.eq(node.style.top, "16px", "node.style.top is correct"); 
    526         t.eq(node.style.width, "4px", "node.style.width is correct"); 
    527         t.eq(node.style.height, "4px", "node.style.height is correct"); 
    528         t.eq(node.coordorigin, "10 16", "node.coordorigin is correct"); 
    529         t.eq(node.coordsize, "4 4", "node.coordsize is correct"); 
    530     } 
    531      
    532     function test_VML_drawpolygon(t) { 
    533         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    534             t.plan(0); 
    535             return; 
    536         } 
    537          
    538         t.plan(2); 
    539          
    540         var r = new OpenLayers.Renderer.VML(document.body); 
    541         r.resolution = 0.5; 
    542          
    543         g_SetNodeDimension = false; 
    544         r.setNodeDimension = function(){ 
    545             g_SetNodeDimension = true; 
    546         }; 
    547          
    548         var node = document.createElement('div'); 
    549          
    550         var linearRing = { 
    551             components: [{ 
    552                 x: 1, 
    553                 y: 2 
    554             },{ 
    555                 x: 3, 
    556                 y: 4 
    557             }] 
    558         }; 
    559         var linearRing2 = { 
    560             components: [{ 
    561                 x: 5, 
    562                 y: 6 
    563             },{ 
    564                 x: 7, 
    565                 y: 8 
    566             }] 
    567         }; 
    568         var geometry = { 
    569             components: [linearRing, linearRing2] 
    570         }; 
    571         r.drawPolygon(node, geometry, true); 
    572         t.ok(g_SetNodeDimension, "setNodeDimension is called"); 
    573         t.eq(node.path, "m 2,4 l 6,8 x m 10,12 l 14,16 x e", "path attribute is correct"); 
    574     } 
    575      
    576     function test_VML_drawrectangle(t) { 
    577         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    578             t.plan(0); 
    579             return; 
    580         } 
    581          
    582         t.plan(4); 
    583          
    584         var r = new OpenLayers.Renderer.VML(document.body); 
    585         r.resolution = 0.5; 
    586          
    587         var node = document.createElement('div'); 
    588          
    589         var geometry = { 
    590             x: 1, 
    591             y: 2, 
    592             width: 3, 
    593             height: 4 
    594         } 
    595          
    596         r.drawRectangle(node, geometry); 
    597          
    598         t.eq(node.style.left, "2px", "node.style.left is correct"); 
    599         t.eq(node.style.top, "4px", "node.style.top is correct"); 
    600         t.eq(node.style.width, "6px", "node.style.width is correct"); 
    601         t.eq(node.style.height, "8px", "node.style.height is correct"); 
    602     } 
    603      
    604  
    605   </script> 
    606 </head> 
    607 <body> 
    608 <div id="map" style="width:500px;height:550px"></div> 
    609 </body> 
    610 </html> 
    611 <html> 
    612 <head> 
    613 <script src="../../lib/OpenLayers.js"></script> 
    614   <script type="text/javascript"> 
    615  
    616     var geometry = null, node = null; 
    617  
    618     function test_VML_constructor(t) { 
    619         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    620             t.plan(0); 
    621             return; 
    622         } 
    623          
    624         t.plan(1); 
    625         var r = new OpenLayers.Renderer.VML(document.body); 
    626         t.ok(r instanceof OpenLayers.Renderer.VML, "new OpenLayers.Renderer.VML returns VML object" ); 
    627     } 
    628      
    629     function test_VML_destroy(t) { 
    630         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    631             t.plan(0); 
    632             return; 
    633         } 
    634          
    635         t.plan(1); 
    636          
    637         var g_Destroy = false; 
    638          
    639         OpenLayers.Renderer.Elements.prototype._destroy =  
    640             OpenLayers.Renderer.Elements.prototype.destroy; 
    641              
    642         OpenLayers.Renderer.prototype.destroy = function() { 
    643             g_Destroy = true; 
    644         } 
    645          
    646         var r = new OpenLayers.Renderer.VML(document.body); 
    647         r.destroy(); 
    648          
    649         t.eq(g_Destroy, true, "OpenLayers.Renderer.Elements.destroy() called"); 
    650          
    651         OpenLayers.Renderer.prototype.destroy =  
    652             OpenLayers.Renderer.prototype._destroy; 
    653     } 
    654      
    655     function test_VML_setextent(t) { 
    656         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    657             t.plan(0); 
    658             return; 
    659         } 
    660          
    661         t.plan(3); 
    662          
    663         OpenLayers.Renderer.Elements.prototype._setExtent = 
    664             OpenLayers.Renderer.Elements.prototype.setExtent; 
    665          
    666         var g_SetExtent = false; 
    667         OpenLayers.Renderer.Elements.prototype.setExtent = function() { 
    668             g_SetExtent = true; 
    669         } 
    670                  
    671         var r = new OpenLayers.Renderer.VML(document.body); 
    672         r.map = { 
    673             getResolution: function() { 
    674                 return 0.5; 
    675             } 
    676         } 
    677          
    678         var extent = new OpenLayers.Bounds(1,2,3,4); 
    679         r.setExtent(extent); 
    680          
    681         t.eq(g_SetExtent, true, "Elements.setExtent() called"); 
    682          
    683         t.ok(r.root.coordorigin == "2,8", "coordorigin is correct"); 
    684         t.ok(r.root.coordsize == "4,-4", "coordsize is correct"); 
    685          
    686         OpenLayers.Renderer.Elements.prototype.setExtent = 
    687             OpenLayers.Renderer.Elements.prototype._setExtent; 
    688     } 
    689  
    690     function test_VML_setsize(t) { 
    691         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    692             t.plan(0); 
    693             return; 
    694         } 
    695          
    696         t.plan(4); 
    697                  
    698         var r = new OpenLayers.Renderer.VML(document.body); 
    699          
    700         var size = new OpenLayers.Size(1,2); 
    701         r.setSize(size); 
    702         t.eq(r.rendererRoot.style.width, "1px", "rendererRoot width is correct"); 
    703         t.eq(r.rendererRoot.style.height, "2px", "rendererRoot height is correct"); 
    704          
    705         t.eq(r.root.style.width, "100%", "root width is correct"); 
    706         t.eq(r.root.style.height, "100%", "root height is correct"); 
    707     } 
    708  
    709     function test_VML_drawpoint(t) { 
    710         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    711             t.plan(0); 
    712             return; 
    713         } 
    714      
    715         t.plan(1); 
    716  
    717         var r = new OpenLayers.Renderer.VML(document.body); 
    718          
    719         var properDraw = false; 
    720         var g_Radius = null; 
    721         r.drawCircle = function(n, g, r) { 
    722             properDraw = true; 
    723             g_Radius = 1; 
    724         } 
    725         r.drawPoint(); 
    726          
    727         t.ok(properDraw && g_Radius == 1, "drawPoint called drawCircle with radius set to 1"); 
    728     } 
    729  
    730     function test_VML_drawcircle(t) { 
    731         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    732             t.plan(0); 
    733             return; 
    734         } 
    735          
    736         t.plan(4); 
    737          
    738         var r = new OpenLayers.Renderer.VML(document.body); 
    739         r.resolution = 0.5; 
    740          
    741         var node = document.createElement('div'); 
    742          
    743         var geometry = { 
    744             x: 1, 
    745             y: 2 
    746         } 
    747          
    748         var radius = 3; 
    749         r.drawCircle(node, geometry, radius); 
    750          
    751         t.eq(node.style.left, '-1px', "left is correct"); 
    752         t.eq(node.style.top, '1px', "top is correct"); 
    753         t.eq(node.style.width, (2 * radius) + "px", "width is correct"); 
    754         t.eq(node.style.height, (2 * radius) + "px", "height is correct"); 
    755     } 
    756  
    757     function test_VML_drawlinestring(t) { 
    758         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    759             t.plan(0); 
    760             return; 
    761         } 
    762          
    763         t.plan(1); 
    764          
    765         var r = new OpenLayers.Renderer.VML(document.body); 
    766          
    767         g_DrawLine = false; 
    768         r.drawLine = function(c) { 
    769             g_DrawLine = true; 
    770         } 
    771          
    772         r.drawLineString(node, geometry); 
    773          
    774         t.ok(g_DrawLine, "drawLine is called"); 
    775     } 
    776      
    777     function test_VML_drawlinearring(t) { 
    778         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    779             t.plan(0); 
    780             return; 
    781         } 
    782          
    783         t.plan(1); 
    784          
    785         var r = new OpenLayers.Renderer.VML(document.body); 
    786          
    787         g_DrawLine = false; 
    788         r.drawLine = function(c) { 
    789             g_DrawLine = true; 
    790         } 
    791          
    792         r.drawLinearRing(node, geometry); 
    793          
    794         t.ok(g_DrawLine, "drawLine is called"); 
    795     } 
    796  
    797     function test_VML_drawline(t) { 
    798         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    799             t.plan(0); 
    800             return; 
    801         } 
    802          
    803         t.plan(8); 
    804          
    805         var r = new OpenLayers.Renderer.VML(document.body); 
    806         r.resolution = 0.5; 
    807          
    808         var node = document.createElement('div'); 
    809          
    810         var geometry = { 
    811             components: [{ 
    812                 x: 1, 
    813                 y: 2 
    814             },{ 
    815                 x: 3, 
    816                 y: 4 
    817             }], 
    818             getBounds: function() { 
    819                 return new OpenLayers.Bounds(5,6,7,8); 
    820             } 
    821         }; 
    822          
    823         r.drawLine(node, geometry, true); 
    824         t.ok(node.path.indexOf("x") != -1, "path attribute is correct when passed closeLine = true"); 
    825          
    826          
    827         r.drawLine(node, geometry, false); 
    828         t.eq(node.path, "m 2,4 l  6,8 l  e", "path attribute is correct"); 
    829         t.eq(node.style.left, "10px", "node.style.left is correct"); 
    830         t.eq(node.style.top, "16px", "node.style.top is correct"); 
    831         t.eq(node.style.width, "4px", "node.style.width is correct"); 
    832         t.eq(node.style.height, "4px", "node.style.height is correct"); 
    833         t.eq(node.coordorigin, "10 16", "node.coordorigin is correct"); 
    834         t.eq(node.coordsize, "4 4", "node.coordsize is correct"); 
    835     } 
    836      
    837     function test_VML_drawpolygon(t) { 
    838         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    839             t.plan(0); 
    840             return; 
    841         } 
    842          
    843         t.plan(2); 
    844          
    845         var r = new OpenLayers.Renderer.VML(document.body); 
    846         r.resolution = 0.5; 
    847          
    848         g_SetNodeDimension = false; 
    849         r.setNodeDimension = function(){ 
    850             g_SetNodeDimension = true; 
    851         }; 
    852          
    853         var node = document.createElement('div'); 
    854          
    855         var linearRing = { 
    856             components: [{ 
    857                 x: 1, 
    858                 y: 2 
    859             },{ 
    860                 x: 3, 
    861                 y: 4 
    862             }] 
    863         }; 
    864         var linearRing2 = { 
    865             components: [{ 
    866                 x: 5, 
    867                 y: 6 
    868             },{ 
    869                 x: 7, 
    870                 y: 8 
    871             }] 
    872         }; 
    873         var geometry = { 
    874             components: [linearRing, linearRing2] 
    875         }; 
    876         r.drawPolygon(node, geometry, true); 
    877         t.ok(g_SetNodeDimension, "setNodeDimension is called"); 
    878         t.eq(node.path, "m 2,4 l 6,8 x m 10,12 l 14,16 x e", "path attribute is correct"); 
    879     } 
    880      
    881     function test_VML_drawrectangle(t) { 
    882         if (!OpenLayers.Renderer.VML.prototype.supported()) { 
    883             t.plan(0); 
    884             return; 
    885         } 
    886          
    887         t.plan(4); 
    888          
    889         var r = new OpenLayers.Renderer.VML(document.body); 
    890         r.resolution = 0.5; 
    891          
    892         var node = document.createElement('div'); 
    893          
    894         var geometry = { 
    895             x: 1, 
    896             y: 2, 
    897             width: 3, 
    898             height: 4 
    899         } 
    900          
    901         r.drawRectangle(node, geometry); 
    902          
    903         t.eq(node.style.left, "2px", "node.style.left is correct"); 
    904         t.eq(node.style.top, "4px", "node.style.top is correct"); 
    905         t.eq(node.style.width, "6px", "node.style.width is correct"); 
    906         t.eq(node.style.height, "8px", "node.style.height is correct"); 
    907     } 
    908      
    909  
    910   </script> 
    911 </head> 
    912 <body> 
    913 <div id="map" style="width:500px;height:550px"></div> 
    914 </body> 
    915 </html> 
     305</html> 

  • tests/Renderer/test_SVG.html

    <
    old new  
    365365<body> 
    366366<div id="map" style="width:500px;height:550px"></div> 
    367367</body> 
    368 </html> 
    369 <html> 
    370 <head> 
    371 <script src="../../lib/OpenLayers.js"></script> 
    372   <script type="text/javascript"> 
    373  
    374     var geometry = null, node = null; 
    375      
    376     function test_SVG_constructor(t) { 
    377         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    378             t.plan(0); 
    379             return; 
    380         } 
    381          
    382         t.plan(1); 
    383         var r = new OpenLayers.Renderer.SVG(document.body); 
    384         t.ok(r instanceof OpenLayers.Renderer.SVG, "new OpenLayers.Renderer.SVG returns SVG object" ); 
    385     } 
    386      
    387     function test_SVG_destroy(t) { 
    388         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    389             t.plan(0); 
    390             return; 
    391         } 
    392          
    393         t.plan(1); 
    394          
    395         var g_Destroy = false; 
    396          
    397         OpenLayers.Renderer.Elements.prototype._destroy =  
    398             OpenLayers.Renderer.Elements.prototype.destroy; 
    399              
    400         OpenLayers.Renderer.prototype.destroy = function() { 
    401             g_Destroy = true; 
    402         } 
    403          
    404         var r = new OpenLayers.Renderer.SVG(document.body); 
    405         r.destroy(); 
    406          
    407         t.eq(g_Destroy, true, "OpenLayers.Renderer.Elements.destroy() called"); 
    408          
    409         OpenLayers.Renderer.prototype.destroy =  
    410             OpenLayers.Renderer.prototype._destroy; 
    411     } 
    412      
    413     function test_SVG_setextent(t) { 
    414         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    415             t.plan(0); 
    416             return; 
    417         } 
    418          
    419         t.plan(5); 
    420          
    421         OpenLayers.Renderer.Elements.prototype._setExtent = 
    422             OpenLayers.Renderer.Elements.prototype.setExtent; 
    423          
    424         var g_SetExtent = false; 
    425         OpenLayers.Renderer.Elements.prototype.setExtent = function() { 
    426             g_SetExtent = true; 
    427         } 
    428                  
    429         var r = new OpenLayers.Renderer.SVG(document.body); 
    430         r.map = { 
    431             getResolution: function() { 
    432                 return 0.5; 
    433             } 
    434         } 
    435          
    436         var extent = new OpenLayers.Bounds(1,2,3,4); 
    437         r.setExtent(extent); 
    438          
    439         t.eq(g_SetExtent, true, "Elements.setExtent() called"); 
    440          
    441         t.eq(r.left, -2, "left is correct"); 
    442         t.eq(r.top, 8, "top is correct"); 
    443          
    444         t.eq(r.rendererRoot.getAttributeNS(null, "viewBox"), "0 0 4 4", "rendererRoot viewBox is correct"); 
    445          
    446         // test extent changes 
    447         var extent = new OpenLayers.Bounds(4,3,2,1); 
    448         r.setExtent(extent); 
    449         t.eq(r.rendererRoot.getAttributeNS(null, "viewBox"), "6 6 -4 -4", "rendererRoot viewBox is correct after a new setExtent"); 
    450  
    451         OpenLayers.Renderer.Elements.prototype.setExtent = 
    452             OpenLayers.Renderer.Elements.prototype._setExtent; 
    453     } 
    454      
    455     function test_SVG_setsize(t) { 
    456         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    457             t.plan(0); 
    458             return; 
    459         } 
    460          
    461         t.plan(2); 
    462                  
    463         var r = new OpenLayers.Renderer.SVG(document.body); 
    464          
    465         var size = new OpenLayers.Size(1,2); 
    466         r.setSize(size); 
    467         t.eq(r.rendererRoot.getAttributeNS(null, "width"), size.w.toString(), "width is correct"); 
    468         t.eq(r.rendererRoot.getAttributeNS(null, "height"), size.h.toString(), "height is correct"); 
    469     } 
    470      
    471     function test_SVG_drawpoint(t) { 
    472         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    473             t.plan(0); 
    474             return; 
    475         } 
    476      
    477         t.plan(1); 
    478  
    479         var r = new OpenLayers.Renderer.SVG(document.body); 
    480          
    481         var properDraw = false; 
    482         var g_Radius = null; 
    483         r.drawCircle = function(n, g, r) { 
    484             properDraw = true; 
    485             g_Radius = 1; 
    486         } 
    487         r.drawPoint(); 
    488          
    489         t.ok(properDraw && g_Radius == 1, "drawPoint called drawCircle with radius set to 1"); 
    490     } 
    491      
    492     function test_SVG_drawcircle(t) { 
    493         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    494             t.plan(0); 
    495             return; 
    496         } 
    497          
    498         t.plan(3); 
    499          
    500         var r = new OpenLayers.Renderer.SVG(document.body); 
    501         r.resolution = 0.5; 
    502         r.left = 0; 
    503         r.top = 0; 
    504          
    505         var node = document.createElement('div'); 
    506          
    507         var geometry = { 
    508             x: 1, 
    509             y: 2 
    510         } 
    511          
    512         r.drawCircle(node, geometry, 3); 
    513          
    514         t.eq(node.getAttributeNS(null, 'cx'), '2', "cx is correct"); 
    515         t.eq(node.getAttributeNS(null, 'cy'), '4', "cy is correct"); 
    516         t.eq(node.getAttributeNS(null, 'r'), '3', "r is correct"); 
    517     } 
    518      
    519     function test_SVG_drawlinestring(t) { 
    520         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    521             t.plan(0); 
    522             return; 
    523         } 
    524          
    525         t.plan(2); 
    526          
    527         var r = new OpenLayers.Renderer.SVG(document.body); 
    528          
    529         var node = document.createElement('div'); 
    530          
    531         var geometry = { 
    532             components: "foo" 
    533         } 
    534         g_GetString = false; 
    535         g_Components = null; 
    536         r.getComponentsString = function(c) { 
    537             g_GetString = true; 
    538             g_Components = c; 
    539             return "bar"; 
    540         } 
    541          
    542         r.drawLineString(node, geometry); 
    543          
    544         t.ok(g_GetString && g_Components == "foo", "getComponentString is called with valid arguments"); 
    545         t.eq(node.getAttributeNS(null, "points"), "bar", "points attribute is correct"); 
    546     } 
    547      
    548     function test_SVG_drawlinearring(t) { 
    549         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    550             t.plan(0); 
    551             return; 
    552         } 
    553          
    554         t.plan(2); 
    555          
    556         var r = new OpenLayers.Renderer.SVG(document.body); 
    557          
    558         var node = document.createElement('div'); 
    559          
    560         var geometry = { 
    561             components: "foo" 
    562         } 
    563         g_GetString = false; 
    564         g_Components = null; 
    565         r.getComponentsString = function(c) { 
    566             g_GetString = true; 
    567             g_Components = c; 
    568             return "bar"; 
    569         } 
    570          
    571         r.drawLinearRing(node, geometry); 
    572          
    573         t.ok(g_GetString, "getComponentString is called with valid arguments"); 
    574         t.eq(node.getAttributeNS(null, "points"), "bar", "points attribute is correct"); 
    575     } 
    576  
    577     function test_SVG_drawpolygon(t) { 
    578         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    579             t.plan(0); 
    580             return; 
    581         } 
    582          
    583         t.plan(4); 
    584          
    585         var r = new OpenLayers.Renderer.SVG(document.body); 
    586          
    587         var node = document.createElement('div'); 
    588          
    589         var linearRings = [{ 
    590             components: ["foo"] 
    591         },{ 
    592             components: ["bar"] 
    593         }] 
    594          
    595         var geometry = { 
    596             components: linearRings 
    597         } 
    598         g_GetString = false; 
    599         r.getShortString = function(c) { 
    600             g_GetString = true; 
    601             return c; 
    602         } 
    603          
    604         r.drawPolygon(node, geometry); 
    605          
    606         t.ok(g_GetString, "getShortString is called"); 
    607         t.eq(node.getAttributeNS(null, "d"), " M foo M bar z", "d attribute is correctly set"); 
    608         t.eq(node.getAttributeNS(null, "fill-rule"), "evenodd", "fill-rule attribute is correctly set"); 
    609          
    610         r.getShortString = function(c) { 
    611             return false; 
    612         } 
    613         r.drawPolygon(node, geometry); 
    614         t.eq(node.getAttributeNS(null, "d"), "", "d attribute is empty if one linearRing cannot be drawn"); 
    615     } 
    616  
    617     function test_SVG_drawrectangle(t) { 
    618         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    619             t.plan(0); 
    620             return; 
    621         } 
    622          
    623         t.plan(4); 
    624          
    625         var r = new OpenLayers.Renderer.SVG(document.body); 
    626         r.resolution = 0.5; 
    627         r.left = 0; 
    628         r.top = 0; 
    629          
    630         var node = document.createElement('div'); 
    631          
    632         var geometry = { 
    633             x: 1, 
    634             y: 2, 
    635             width: 3, 
    636             height: 4 
    637         } 
    638          
    639         r.drawRectangle(node, geometry); 
    640          
    641         t.eq(node.getAttributeNS(null, "x"), "2", "x attribute is correctly set"); 
    642         t.eq(node.getAttributeNS(null, "y"), "4", "y attribute is correctly set"); 
    643         t.eq(node.getAttributeNS(null, "width"), "6", "width attribute is correctly set"); 
    644         t.eq(node.getAttributeNS(null, "height"), "8", "height attribute is correctly set"); 
    645     } 
    646      
    647     function test_SVG_drawsurface(t) { 
    648         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    649             t.plan(0); 
    650             return; 
    651         } 
    652          
    653         t.plan(3); 
    654          
    655         var r = new OpenLayers.Renderer.SVG(document.body); 
    656          
    657         var node = document.createElement('div'); 
    658          
    659         var geometry = { 
    660             components: ['foo', 'bar', 'dude'] 
    661         } 
    662         g_GetString = false; 
    663         r.getShortString = function(c) { 
    664             g_GetString = true; 
    665             return c; 
    666         } 
    667          
    668         r.drawSurface(node, geometry); 
    669          
    670         t.ok(g_GetString, "getShortString is called"); 
    671          
    672         t.eq(node.getAttributeNS(null, "d"), "M foo C bar dude Z", "d attribute is correctly set"); 
    673          
    674         r.getShortString = function(c) { 
    675             return false; 
    676         } 
    677         r.drawSurface(node, geometry); 
    678         t.eq(node.getAttributeNS(null, "d"), "", "d attribute is empty if one linearRing cannot be drawn"); 
    679     } 
    680      
    681     function test_SVG_getcomponentsstring(t) { 
    682         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    683             t.plan(0); 
    684             return; 
    685         } 
    686          
    687         t.plan(1); 
    688          
    689         var components = ['foo', 'bar']; 
    690          
    691         OpenLayers.Renderer.SVG.prototype._getShortString =  
    692             OpenLayers.Renderer.SVG.prototype.getShortString; 
    693              
    694         OpenLayers.Renderer.SVG.prototype.getShortString = function(p) { 
    695             return p; 
    696         }; 
    697          
    698         var string = OpenLayers.Renderer.SVG.prototype.getComponentsString(components); 
    699         t.eq(string, "foo,bar", "returned string is correct"); 
    700          
    701         OpenLayers.Renderer.SVG.prototype.getShortString =  
    702             OpenLayers.Renderer.SVG.prototype._getShortString; 
    703     } 
    704      
    705      
    706      
    707     function test_SVG_getshortstring(t) { 
    708         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    709             t.plan(0); 
    710             return; 
    711         } 
    712          
    713         t.plan(1); 
    714          
    715         var r = new OpenLayers.Renderer.SVG(document.body); 
    716         r.resolution = 0.5; 
    717         r.left = 0; 
    718         r.top = 0; 
    719          
    720         var point = { 
    721             x: 1, 
    722             y: 2 
    723         }; 
    724          
    725         var string = r.getShortString(point); 
    726         t.eq(string, "2,4", "returned string is correct"); 
    727     } 
    728      
    729      
    730  
    731   </script> 
    732 </head> 
    733 <body> 
    734 <div id="map" style="width:500px;height:550px"></div> 
    735 </body> 
    736 </html> 
    737 <html> 
    738 <head> 
    739 <script src="../../lib/OpenLayers.js"></script> 
    740   <script type="text/javascript"> 
    741  
    742     var geometry = null, node = null; 
    743      
    744     function test_SVG_constructor(t) { 
    745         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    746             t.plan(0); 
    747             return; 
    748         } 
    749          
    750         t.plan(1); 
    751         var r = new OpenLayers.Renderer.SVG(document.body); 
    752         t.ok(r instanceof OpenLayers.Renderer.SVG, "new OpenLayers.Renderer.SVG returns SVG object" ); 
    753     } 
    754      
    755     function test_SVG_destroy(t) { 
    756         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    757             t.plan(0); 
    758             return; 
    759         } 
    760          
    761         t.plan(1); 
    762          
    763         var g_Destroy = false; 
    764          
    765         OpenLayers.Renderer.Elements.prototype._destroy =  
    766             OpenLayers.Renderer.Elements.prototype.destroy; 
    767              
    768         OpenLayers.Renderer.prototype.destroy = function() { 
    769             g_Destroy = true; 
    770         } 
    771          
    772         var r = new OpenLayers.Renderer.SVG(document.body); 
    773         r.destroy(); 
    774          
    775         t.eq(g_Destroy, true, "OpenLayers.Renderer.Elements.destroy() called"); 
    776          
    777         OpenLayers.Renderer.prototype.destroy =  
    778             OpenLayers.Renderer.prototype._destroy; 
    779     } 
    780      
    781     function test_SVG_setextent(t) { 
    782         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    783             t.plan(0); 
    784             return; 
    785         } 
    786          
    787         t.plan(5); 
    788          
    789         OpenLayers.Renderer.Elements.prototype._setExtent = 
    790             OpenLayers.Renderer.Elements.prototype.setExtent; 
    791          
    792         var g_SetExtent = false; 
    793         OpenLayers.Renderer.Elements.prototype.setExtent = function() { 
    794             g_SetExtent = true; 
    795         } 
    796                  
    797         var r = new OpenLayers.Renderer.SVG(document.body); 
    798         r.map = { 
    799             getResolution: function() { 
    800                 return 0.5; 
    801             } 
    802         } 
    803          
    804         var extent = new OpenLayers.Bounds(1,2,3,4); 
    805         r.setExtent(extent); 
    806          
    807         t.eq(g_SetExtent, true, "Elements.setExtent() called"); 
    808          
    809         t.eq(r.left, -2, "left is correct"); 
    810         t.eq(r.top, 8, "top is correct"); 
    811          
    812         t.eq(r.rendererRoot.getAttributeNS(null, "viewBox"), "0 0 4 4", "rendererRoot viewBox is correct"); 
    813          
    814         // test extent changes 
    815         var extent = new OpenLayers.Bounds(4,3,2,1); 
    816         r.setExtent(extent); 
    817         t.eq(r.rendererRoot.getAttributeNS(null, "viewBox"), "6 6 -4 -4", "rendererRoot viewBox is correct after a new setExtent"); 
    818  
    819         OpenLayers.Renderer.Elements.prototype.setExtent = 
    820             OpenLayers.Renderer.Elements.prototype._setExtent; 
    821     } 
    822      
    823     function test_SVG_setsize(t) { 
    824         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    825             t.plan(0); 
    826             return; 
    827         } 
    828          
    829         t.plan(2); 
    830                  
    831         var r = new OpenLayers.Renderer.SVG(document.body); 
    832          
    833         var size = new OpenLayers.Size(1,2); 
    834         r.setSize(size); 
    835         t.eq(r.rendererRoot.getAttributeNS(null, "width"), size.w.toString(), "width is correct"); 
    836         t.eq(r.rendererRoot.getAttributeNS(null, "height"), size.h.toString(), "height is correct"); 
    837     } 
    838      
    839     function test_SVG_drawpoint(t) { 
    840         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    841             t.plan(0); 
    842             return; 
    843         } 
    844      
    845         t.plan(1); 
    846  
    847         var r = new OpenLayers.Renderer.SVG(document.body); 
    848          
    849         var properDraw = false; 
    850         var g_Radius = null; 
    851         r.drawCircle = function(n, g, r) { 
    852             properDraw = true; 
    853             g_Radius = 1; 
    854         } 
    855         r.drawPoint(); 
    856          
    857         t.ok(properDraw && g_Radius == 1, "drawPoint called drawCircle with radius set to 1"); 
    858     } 
    859      
    860     function test_SVG_drawcircle(t) { 
    861         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    862             t.plan(0); 
    863             return; 
    864         } 
    865          
    866         t.plan(3); 
    867          
    868         var r = new OpenLayers.Renderer.SVG(document.body); 
    869         r.resolution = 0.5; 
    870         r.left = 0; 
    871         r.top = 0; 
    872          
    873         var node = document.createElement('div'); 
    874          
    875         var geometry = { 
    876             x: 1, 
    877             y: 2 
    878         } 
    879          
    880         r.drawCircle(node, geometry, 3); 
    881          
    882         t.eq(node.getAttributeNS(null, 'cx'), '2', "cx is correct"); 
    883         t.eq(node.getAttributeNS(null, 'cy'), '4', "cy is correct"); 
    884         t.eq(node.getAttributeNS(null, 'r'), '3', "r is correct"); 
    885     } 
    886      
    887     function test_SVG_drawlinestring(t) { 
    888         if (!OpenLayers.Renderer.SVG.prototype.supported()) { 
    889             t.plan(0); 
    890             return; 
    891         } 
    892          
    893         t.plan(2); 
    894