From 75a1a8e119b2948bc57340daad231dbb6cba364d Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Wed, 26 Oct 2011 15:22:13 -0600
Subject: [PATCH 1/7] Allow setting center from array.

---
 lib/OpenLayers/BaseTypes/LonLat.js |  4 ++++
 lib/OpenLayers/Map.js              |  3 +++
 tests/BaseTypes/LonLat.html        |  8 +++++++-
 tests/Map.html                     | 30 ++++++++++++++++++++++++++++--
 4 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/lib/OpenLayers/BaseTypes/LonLat.js b/lib/OpenLayers/BaseTypes/LonLat.js
index 70c883d4f1..77206f4217 100644
--- a/lib/OpenLayers/BaseTypes/LonLat.js
+++ b/lib/OpenLayers/BaseTypes/LonLat.js
@@ -38,6 +38,10 @@ OpenLayers.LonLat = OpenLayers.Class({
      *     it will be the y coordinate of the map location in your map units.
      */
     initialize: function(lon, lat) {
+        if (OpenLayers.Util.isArray(lon)) {
+            lat = lon[1];
+            lon = lon[0];
+        }
         this.lon = OpenLayers.Util.toFloat(lon);
         this.lat = OpenLayers.Util.toFloat(lat);
     },
diff --git a/lib/OpenLayers/Map.js b/lib/OpenLayers/Map.js
index 8ce24e374d..90ead46cd4 100644
--- a/lib/OpenLayers/Map.js
+++ b/lib/OpenLayers/Map.js
@@ -1703,6 +1703,9 @@ OpenLayers.Map = OpenLayers.Class({
      * options - {Object}
      */
     moveTo: function(lonlat, zoom, options) {
+        if (!(lonlat instanceof OpenLayers.LonLat)) {
+            lonlat = new OpenLayers.LonLat(lonlat);
+        }
         if (!options) { 
             options = {};
         }
diff --git a/tests/BaseTypes/LonLat.html b/tests/BaseTypes/LonLat.html
index 3135a41ae3..d5283cf286 100644
--- a/tests/BaseTypes/LonLat.html
+++ b/tests/BaseTypes/LonLat.html
@@ -6,7 +6,7 @@
     var lonlat; 
 
     function test_LonLat_constructor (t) {
-        t.plan( 6 );
+        t.plan( 8 );
         lonlat = new OpenLayers.LonLat(6, 5);
         t.ok( lonlat instanceof OpenLayers.LonLat, "new OpenLayers.LonLat returns LonLat object" );
         t.eq( lonlat.CLASS_NAME, "OpenLayers.LonLat", "lonlat.CLASS_NAME is set correctly");
@@ -17,6 +17,12 @@
         lonlat = new OpenLayers.LonLat(20037508.33999999, -20037508.33999999);
         t.eq( lonlat.lon, 20037508.34, "lonlat.lon rounds correctly");
         t.eq( lonlat.lat, -20037508.34, "lonlat.lat rounds correctly");
+        
+        // allow construction from single arg
+        lonlat = new OpenLayers.LonLat([1, 2]);
+        t.eq(lonlat.lon, 1, "lon from array");
+        t.eq(lonlat.lat, 2, "lat from array");
+        
     }
     
     function test_LonLat_constructorFromStrings (t) {
diff --git a/tests/Map.html b/tests/Map.html
index 4e93f104b6..3476ab959c 100644
--- a/tests/Map.html
+++ b/tests/Map.html
@@ -37,6 +37,25 @@
         map.destroy();
     }
     
+    function test_Map_constructor_convenience(t) {
+        t.plan(3);
+        var map = new OpenLayers.Map({
+            layers: [
+                new OpenLayers.Layer(null, {isBaseLayer: true})
+            ],
+            center: [-111, 45],
+            zoom: 3
+        });
+        
+        var center = map.getCenter();
+        t.eq(center.lon, -111, "center lon");
+        t.eq(center.lat, 45, "center lat");
+        
+        t.eq(map.getZoom(), 3, "zoom");
+        
+        map.destroy();
+    }
+    
     function test_Map_constructor_late_rendering(t) {
         t.plan( 4 );
         
@@ -163,7 +182,7 @@
     }
 
     function test_Map_center(t) {
-        t.plan(11);
+        t.plan(14);
         var log = [];
         map = new OpenLayers.Map('map', {
             eventListeners: {
@@ -186,7 +205,7 @@
         t.ok( map.getCenter().equals(ll), "map center is correct after calling setCenter, zoom in");
         map.zoomOut();
         t.eq( map.getZoom(), 0, "map.zoom is correct after calling setCenter,zoom in, zoom out");
-
+        
         log = [];
         map.zoomTo(5);
         t.eq(log[0], "movestart", "zoomTo fires movestart event");
@@ -205,6 +224,13 @@
         map.getCenter().lon = 10;
         t.ok( map.getCenter().equals(ll), "map.getCenter returns a clone of map.center");
 
+        // allow calling setCenter with an array
+        map.setCenter([4, 2]);
+        var center = map.getCenter();
+        t.ok(center instanceof OpenLayers.LonLat, "(array) center is lonlat");
+        t.eq(center.lon, 4, "(array) center lon");
+        t.eq(center.lat, 2, "(array) center lat");
+
         map.destroy();
     }
 

From 98ee7167c43cc828429c5d407b67b6993fea3554 Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Wed, 26 Oct 2011 15:40:40 -0600
Subject: [PATCH 2/7] Allow use of array for bounds.

---
 lib/OpenLayers/BaseTypes/Bounds.js |  6 ++++++
 lib/OpenLayers/Map.js              | 11 +++++++++++
 tests/BaseTypes/Bounds.html        | 11 ++++++++++-
 tests/Map.html                     | 27 +++++++++++++++++++++++++--
 4 files changed, 52 insertions(+), 3 deletions(-)

diff --git a/lib/OpenLayers/BaseTypes/Bounds.js b/lib/OpenLayers/BaseTypes/Bounds.js
index 5935ccbe1a..9eefcc1831 100644
--- a/lib/OpenLayers/BaseTypes/Bounds.js
+++ b/lib/OpenLayers/BaseTypes/Bounds.js
@@ -67,6 +67,12 @@ OpenLayers.Bounds = OpenLayers.Class({
      * top - {Number} The top bounds.
      */
     initialize: function(left, bottom, right, top) {
+        if (OpenLayers.Util.isArray(left)) {
+            top = left[3];
+            right = left[2];
+            bottom = left[1];
+            left = left[0];
+        }
         if (left != null) {
             this.left = OpenLayers.Util.toFloat(left);
         }
diff --git a/lib/OpenLayers/Map.js b/lib/OpenLayers/Map.js
index 90ead46cd4..33daa3a66c 100644
--- a/lib/OpenLayers/Map.js
+++ b/lib/OpenLayers/Map.js
@@ -478,6 +478,14 @@ OpenLayers.Map = OpenLayers.Class({
 
         // now override default options 
         OpenLayers.Util.extend(this, options);
+        
+        // allow extents to be arrays
+        if (this.maxExtent && !(this.maxExtent instanceof OpenLayers.Bounds)) {
+            this.maxExtent = new OpenLayers.Bounds(this.maxExtent);
+        }
+        if (this.restrictedExtent && !(this.restrictedExtent instanceof OpenLayers.Bounds)) {
+            this.restrictedExtent = new OpenLayers.Bounds(this.restrictedExtent);
+        }
 
         // initialize layers array
         this.layers = [];
@@ -2211,6 +2219,9 @@ OpenLayers.Map = OpenLayers.Class({
      * 
      */
     zoomToExtent: function(bounds, closest) {
+        if (!(bounds instanceof OpenLayers.Bounds)) {
+            bounds = new OpenLayers.Bounds(bounds);
+        }
         var center = bounds.getCenterLonLat();
         if (this.baseLayer.wrapDateLine) {
             var maxExtent = this.getMaxExtent();
diff --git a/tests/BaseTypes/Bounds.html b/tests/BaseTypes/Bounds.html
index b436005d1c..b8ff57eceb 100644
--- a/tests/BaseTypes/Bounds.html
+++ b/tests/BaseTypes/Bounds.html
@@ -4,7 +4,7 @@
   <script type="text/javascript">
     var bounds; 
     function test_Bounds_constructor (t) {
-        t.plan( 21 );
+        t.plan( 26 );
         
         bounds = new OpenLayers.Bounds();
         t.ok( bounds instanceof OpenLayers.Bounds, "new OpenLayers.Bounds returns Bounds object" );
@@ -44,6 +44,15 @@
         t.eq( bounds.bottom, -20037508.34, "bounds.bottom adjusted for floating precision");
         t.eq( bounds.right, 40075016.68, "bounds.right adjusted for floating precision");
         t.eq( bounds.top, 20037508.34, "bounds.top adjusted for floating precision");
+        
+        // allow construction from a single arg
+        bounds = new OpenLayers.Bounds([-180, -90, 180, 90]);
+        t.ok(bounds instanceof OpenLayers.Bounds, "(array) correct instance");
+        t.eq(bounds.left, -180, "(array) left");
+        t.eq(bounds.bottom, -90, "(array) bottom");
+        t.eq(bounds.right, 180, "(array) right");
+        t.eq(bounds.top, 90, "(array) top");
+        
     }
 
     function test_Bounds_constructorFromStrings(t) {
diff --git a/tests/Map.html b/tests/Map.html
index 3476ab959c..7d6a0085ff 100644
--- a/tests/Map.html
+++ b/tests/Map.html
@@ -38,8 +38,10 @@
     }
     
     function test_Map_constructor_convenience(t) {
-        t.plan(3);
+        t.plan(13);
         var map = new OpenLayers.Map({
+            maxExtent: [-170, -80, 170, 80],
+            restrictedExtent: [-120, -65, 120, 65],
             layers: [
                 new OpenLayers.Layer(null, {isBaseLayer: true})
             ],
@@ -47,6 +49,20 @@
             zoom: 3
         });
         
+        // maxExtent from array
+        t.ok(map.maxExtent instanceof OpenLayers.Bounds, "maxExtent bounds");
+        t.eq(map.maxExtent.left, -170, "maxExtent left");
+        t.eq(map.maxExtent.bottom, -80, "maxExtent bottom");
+        t.eq(map.maxExtent.right, 170, "maxExtent right");
+        t.eq(map.maxExtent.top, 80, "maxExtent top");
+
+        // restrictedExtent from array
+        t.ok(map.restrictedExtent instanceof OpenLayers.Bounds, "restrictedExtent bounds");
+        t.eq(map.restrictedExtent.left, -120, "restrictedExtent left");
+        t.eq(map.restrictedExtent.bottom, -65, "restrictedExtent bottom");
+        t.eq(map.restrictedExtent.right, 120, "restrictedExtent right");
+        t.eq(map.restrictedExtent.top, 65, "restrictedExtent top");
+        
         var center = map.getCenter();
         t.eq(center.lon, -111, "center lon");
         t.eq(center.lat, 45, "center lat");
@@ -1412,7 +1428,7 @@
     }
     
     function test_Map_zoomToExtent(t) {
-        t.plan(9);
+        t.plan(12);
         
         var map = new OpenLayers.Map("map");
         var layer = new OpenLayers.Layer(null, {isBaseLayer: true});
@@ -1441,6 +1457,13 @@
         t.eq(center.lon, -105, "c) correct x");
         t.eq(center.lat, 42, "c) correct y");
         t.eq(map.getZoom(), 3, "c) correct zoom");
+
+        // accept array
+        map.zoomToExtent([-160, 15, -50, 69]);
+        center = map.getCenter();
+        t.eq(center.lon, -105, "(array) correct x");
+        t.eq(center.lat, 42, "(array) correct y");
+        t.eq(map.getZoom(), 2, "(array) correct zoom");
         
         map.destroy();
     }

From fb790424a5f9361659c41a339991ea55e1ad2ebd Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Wed, 26 Oct 2011 16:02:51 -0600
Subject: [PATCH 3/7] Allow array for min/maxExtent in layers.

---
 lib/OpenLayers/Layer.js | 10 ++++++++++
 tests/Layer.html        | 33 +++++++++++++++++++++++++++++++++
 tests/Layer/WMS.html    | 36 ++++++++++++++++++++++++++++++++++++
 3 files changed, 79 insertions(+)

diff --git a/lib/OpenLayers/Layer.js b/lib/OpenLayers/Layer.js
index 46ec873be7..06940d117a 100644
--- a/lib/OpenLayers/Layer.js
+++ b/lib/OpenLayers/Layer.js
@@ -471,6 +471,16 @@ OpenLayers.Layer = OpenLayers.Class({
         if (this.options == null) {
             this.options = {};
         }
+        
+        // allow array for extents
+        if (newOptions) {
+            if (newOptions.maxExtent && !(newOptions.maxExtent instanceof OpenLayers.Bounds)) {
+                newOptions.maxExtent = new OpenLayers.Bounds(newOptions.maxExtent);
+            }
+            if (newOptions.minExtent && !(newOptions.minExtent instanceof OpenLayers.Bounds)) {
+                newOptions.minExtent = new OpenLayers.Bounds(newOptions.minExtent);
+            }
+        }
 
         // update our copy for clone
         OpenLayers.Util.extend(this.options, newOptions);
diff --git a/tests/Layer.html b/tests/Layer.html
index 92976c6f21..eabd233aee 100644
--- a/tests/Layer.html
+++ b/tests/Layer.html
@@ -197,6 +197,39 @@
         t.eq(layer.numZoomLevels, numZoomLevels, "numZoomLevels set correctly");
     }
     
+    function test_maxExtent(t) {
+        t.plan(5);
+        
+        var layer = new OpenLayers.Layer(
+            null, {maxExtent: [-180, 0, 0, 90]}
+        );
+        
+        t.ok(layer.maxExtent instanceof OpenLayers.Bounds, "(array) bounds instance");
+        t.eq(layer.maxExtent.left, -180, "(array) bounds left");
+        t.eq(layer.maxExtent.bottom, 0, "(array) bounds left");
+        t.eq(layer.maxExtent.right, 0, "(array) bounds right");
+        t.eq(layer.maxExtent.top, 90, "(array) bounds top");
+        
+        layer.destroy();
+    }
+
+    function test_minExtent(t) {
+        t.plan(5);
+        
+        var layer = new OpenLayers.Layer(
+            null, {minExtent: [-180, 0, 0, 90]}
+        );
+        
+        t.ok(layer.minExtent instanceof OpenLayers.Bounds, "(array) bounds instance");
+        t.eq(layer.minExtent.left, -180, "(array) bounds left");
+        t.eq(layer.minExtent.bottom, 0, "(array) bounds left");
+        t.eq(layer.minExtent.right, 0, "(array) bounds right");
+        t.eq(layer.minExtent.top, 90, "(array) bounds top");
+        
+        layer.destroy();
+    }
+
+
     function test_eventListeners(t) {
         t.plan(1);
         
diff --git a/tests/Layer/WMS.html b/tests/Layer/WMS.html
index 51228b0afb..27d69a57bc 100644
--- a/tests/Layer/WMS.html
+++ b/tests/Layer/WMS.html
@@ -378,6 +378,42 @@
 
     }
 
+    function test_maxExtent(t) {
+        t.plan(5);
+        
+        var layer = new OpenLayers.Layer.WMS(
+            null, "http://example.com/wms", 
+            {layers: "foo"}, 
+            {maxExtent: [-180, 0, 0, 90]}
+        );
+        
+        t.ok(layer.maxExtent instanceof OpenLayers.Bounds, "(array) bounds instance");
+        t.eq(layer.maxExtent.left, -180, "(array) bounds left");
+        t.eq(layer.maxExtent.bottom, 0, "(array) bounds left");
+        t.eq(layer.maxExtent.right, 0, "(array) bounds right");
+        t.eq(layer.maxExtent.top, 90, "(array) bounds top");
+        
+        layer.destroy();
+    }
+
+    function test_minExtent(t) {
+        t.plan(5);
+        
+        var layer = new OpenLayers.Layer.WMS(
+            null, "http://example.com/wms", 
+            {layers: "foo"}, 
+            {minExtent: [-180, 0, 0, 90]}
+        );
+        
+        t.ok(layer.minExtent instanceof OpenLayers.Bounds, "(array) bounds instance");
+        t.eq(layer.minExtent.left, -180, "(array) bounds left");
+        t.eq(layer.minExtent.bottom, 0, "(array) bounds left");
+        t.eq(layer.minExtent.right, 0, "(array) bounds right");
+        t.eq(layer.minExtent.top, 90, "(array) bounds top");
+        
+        layer.destroy();
+    }
+
     function test_tileOrigin(t) {
         t.plan(4);
         

From 98d6e7431423b4bec02e05789f0f51d20ea5ca7b Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Wed, 26 Oct 2011 16:22:51 -0600
Subject: [PATCH 4/7] Allow testing for projection equality with string.

---
 lib/OpenLayers/Projection.js | 3 +++
 tests/Projection.html        | 8 +++++++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/lib/OpenLayers/Projection.js b/lib/OpenLayers/Projection.js
index 7e652ba27d..7e42b8459b 100644
--- a/lib/OpenLayers/Projection.js
+++ b/lib/OpenLayers/Projection.js
@@ -101,6 +101,9 @@ OpenLayers.Projection = OpenLayers.Class({
     equals: function(projection) {
         var p = projection, equals = false;
         if (p) {
+            if (!(projection instanceof OpenLayers.Projection)) {
+                projection = new OpenLayers.Projection(projection);
+            }
             if (window.Proj4js && this.proj.defData && p.proj.defData) {
                 equals = this.proj.defData.replace(this.titleRegEx, "") ==
                     p.proj.defData.replace(this.titleRegEx, "");
diff --git a/tests/Projection.html b/tests/Projection.html
index 6ef317dde2..bb458b6f17 100644
--- a/tests/Projection.html
+++ b/tests/Projection.html
@@ -24,7 +24,7 @@
      }
      
      function test_Projection_equals(t) {
-         t.plan(8);
+         t.plan(12);
          var origTransforms = OpenLayers.Util.extend({}, OpenLayers.Projection.transforms);
          OpenLayers.Projection.addTransform("EPSG:4326", "FOO", OpenLayers.Projection.nullTransform);
          OpenLayers.Projection.addTransform("FOO", "EPSG:4326", OpenLayers.Projection.nullTransform);
@@ -57,6 +57,12 @@
          t.eq(proj1.equals(proj4), true, "EPSG:4326 and EPSG:4326 are equal with proj4js");
          t.eq(proj2.equals(proj5), false, "Projection.equals() returns false for unknown projections with proj4js");
          
+         // allow comparison with identifier
+         t.eq(proj1.equals("EPSG:4326"), true, "EPSG:4326 equality with string");
+         t.eq(proj1.equals("EPSG:4327"), false, "EPSG:4326 inequality with string");
+         t.eq(proj1.equals("EPSG:900913"), true, "EPSG:900913 equality with string");
+         t.eq(proj1.equals("EPSG:900914"), false, "EPSG:900913 inequality with string");
+         
          if (!hasProj) {
              window.Proj4js = undefined;
          }

From a606e565d3a26b8d96a22325e78956a68f66bf64 Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Wed, 26 Oct 2011 16:23:48 -0600
Subject: [PATCH 5/7] Allow transforming geometries, lonlat, and bounds with
 strings.

---
 lib/OpenLayers/Projection.js | 19 +++++++++++++------
 tests/BaseTypes/Bounds.html  | 10 +++++++++-
 tests/BaseTypes/LonLat.html  | 12 +++++++++++-
 tests/Geometry/Point.html    | 15 +++++++++++++++
 tests/Geometry/Polygon.html  | 13 +++++++++++++
 5 files changed, 61 insertions(+), 8 deletions(-)

diff --git a/lib/OpenLayers/Projection.js b/lib/OpenLayers/Projection.js
index 7e42b8459b..97eb2f63ba 100644
--- a/lib/OpenLayers/Projection.js
+++ b/lib/OpenLayers/Projection.js
@@ -186,12 +186,19 @@ OpenLayers.Projection.addTransform = function(from, to, method) {
  * point - {object} A transformed coordinate.  The original point is modified.
  */
 OpenLayers.Projection.transform = function(point, source, dest) {
-    if (source.proj && dest.proj) {
-        point = Proj4js.transform(source.proj, dest.proj, point);
-    } else if (source && dest && 
-               OpenLayers.Projection.transforms[source.getCode()] && 
-               OpenLayers.Projection.transforms[source.getCode()][dest.getCode()]) {
-        OpenLayers.Projection.transforms[source.getCode()][dest.getCode()](point); 
+    if (source && dest) {
+        if (!(source instanceof OpenLayers.Projection)) {
+            source = new OpenLayers.Projection(source);
+        }
+        if (!(dest instanceof OpenLayers.Projection)) {
+            dest = new OpenLayers.Projection(dest);
+        }
+        if (source.proj && dest.proj) {
+            point = Proj4js.transform(source.proj, dest.proj, point);
+        } else if (OpenLayers.Projection.transforms[source.getCode()] && 
+                   OpenLayers.Projection.transforms[source.getCode()][dest.getCode()]) {
+            OpenLayers.Projection.transforms[source.getCode()][dest.getCode()](point); 
+        }        
     }
     return point;
 };
diff --git a/tests/BaseTypes/Bounds.html b/tests/BaseTypes/Bounds.html
index b8ff57eceb..a1497cf6da 100644
--- a/tests/BaseTypes/Bounds.html
+++ b/tests/BaseTypes/Bounds.html
@@ -630,7 +630,7 @@
 
     }
     function test_Bounds_transform(t) {
-        t.plan( 3 );
+        t.plan( 5 );
         bounds = new OpenLayers.Bounds(10, -10, 20, 10);
         bounds.transform(new OpenLayers.Projection("foo"), new OpenLayers.Projection("Bar")); 
         t.eq(bounds.toBBOX(), "10,-10,20,10", "null transform okay");
@@ -638,6 +638,14 @@
         t.eq(bounds.toBBOX(), "1113194.907778,-1118889.974702,2226389.815556,1118889.974702", "bounds for spherical mercator transform are correct");
         bounds.transform(new OpenLayers.Projection("EPSG:900913"), new OpenLayers.Projection("EPSG:4326")); 
         t.eq(bounds.toBBOX(), "10,-10,20,10", "bounds for inverse spherical mercator transform are correct");
+
+        // transform with string
+        bounds = new OpenLayers.Bounds(10, -10, 20, 10);
+        bounds.transform("EPSG:4326", "EPSG:900913"); 
+        t.eq(bounds.toBBOX(), "1113194.907778,-1118889.974702,2226389.815556,1118889.974702", "(string) bounds for spherical mercator transform are correct");
+        bounds.transform("EPSG:900913", "EPSG:4326"); 
+        t.eq(bounds.toBBOX(), "10,-10,20,10", "(string) bounds for inverse spherical mercator transform are correct");
+        
     }
 
     function test_Bounds_add(t) {
diff --git a/tests/BaseTypes/LonLat.html b/tests/BaseTypes/LonLat.html
index d5283cf286..a1801f6c6b 100644
--- a/tests/BaseTypes/LonLat.html
+++ b/tests/BaseTypes/LonLat.html
@@ -166,7 +166,7 @@
     }
 
     function test_LonLat_transform(t) {
-        t.plan( 6 );
+        t.plan(10);
         lonlat = new OpenLayers.LonLat(10, -10);
         lonlat.transform(new OpenLayers.Projection("foo"), new OpenLayers.Projection("Bar")); 
         t.eq(lonlat.lon, 10, "lon for null transform is the same")
@@ -177,6 +177,16 @@
         lonlat.transform(new OpenLayers.Projection("EPSG:900913"), new OpenLayers.Projection("EPSG:4326")); 
         t.eq(lonlat.lon, 10, "lon for inverse spherical mercator transform is correct");
         t.eq(Math.round(lonlat.lat), -10, "lat for inverse spherical mercator correct")
+        
+        // transform with string
+        lonlat = new OpenLayers.LonLat(10, -10);
+        lonlat.transform("EPSG:4326", "EPSG:900913"); 
+        t.eq(Math.round(lonlat.lon), 1113195, "(string) lon for spherical mercator transform is correct");
+        t.eq(Math.round(lonlat.lat), -1118890, "(string) lat for spherical mercator correct")
+        lonlat.transform("EPSG:900913", "EPSG:4326"); 
+        t.eq(lonlat.lon, 10, "(string) lon for inverse spherical mercator transform is correct");
+        t.eq(Math.round(lonlat.lat), -10, "(string) lat for inverse spherical mercator correct")
+        
     }
     
     function test_LonLat_wrapDateLine(t) {
diff --git a/tests/Geometry/Point.html b/tests/Geometry/Point.html
index 9baaf5c72b..838a587521 100644
--- a/tests/Geometry/Point.html
+++ b/tests/Geometry/Point.html
@@ -50,6 +50,21 @@
                         new OpenLayers.Projection("EPSG:900913"));
         t.eq(point.bounds, null, "Point bounds cleared after transform");
     }
+
+    function test_Point_transform_string(t) {
+        t.plan(4);
+
+        var x = 10;
+        var y = 20;
+        point = new OpenLayers.Geometry.Point(x, y);
+        point.calculateBounds();
+        t.ok( point.bounds != null, "bounds calculated by calcBounds" );
+        point.transform("EPSG:4326", "EPSG:900913");
+        t.eq(point.bounds, null, "Point bounds cleared after transform");
+        t.eq(point.x.toFixed(2), "1113194.91", "transformed x");
+        t.eq(point.y.toFixed(2), "2273030.93", "transformed y");
+        
+    }
     
     function test_Point_distanceTo(t) {
         t.plan(7);
diff --git a/tests/Geometry/Polygon.html b/tests/Geometry/Polygon.html
index 598b68800e..9f5cd95358 100644
--- a/tests/Geometry/Polygon.html
+++ b/tests/Geometry/Polygon.html
@@ -46,6 +46,19 @@
         t.eq(polygon.getBounds().toBBOX(), "556597.453889,334111.171355,1113194.907778,1574216.547942", "Bounds are correct")
     }
 
+    function test_Polygon_transform_string (t) {
+        t.plan(3);
+
+        var components = [new OpenLayers.Geometry.Point(10,14), new OpenLayers.Geometry.Point(5,3)];
+        var linearRing = new OpenLayers.Geometry.LinearRing(components);
+        polygon = new OpenLayers.Geometry.Polygon([linearRing.clone()]);
+        polygon.calculateBounds();
+        t.ok( polygon.bounds != null, "bounds calculated by calcBounds" );
+        polygon.transform("EPSG:4326", "EPSG:900913");
+        t.eq(polygon.bounds, null, "Point bounds cleared after transform");
+        t.eq(polygon.getBounds().toBBOX(), "556597.453889,334111.171355,1113194.907778,1574216.547942", "Bounds are correct")
+    }
+
     function test_Polygon_getArea(t) {
         t.plan( 5 );
 

From 28cc0bd9621a6773354db5e3b6580e82a17e41d4 Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Fri, 28 Oct 2011 15:53:16 -0600
Subject: [PATCH 6/7] Fewer news.

---
 examples/spherical-mercator.html | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/spherical-mercator.html b/examples/spherical-mercator.html
index fd6a3250da..88e207f27a 100644
--- a/examples/spherical-mercator.html
+++ b/examples/spherical-mercator.html
@@ -41,12 +41,12 @@
 
     var map = new OpenLayers.Map({
         div: "map",
-        projection: new OpenLayers.Projection("EPSG:900913"),
-        displayProjection: new OpenLayers.Projection("EPSG:4326"),
+        projection: "EPSG:900913",
+        displayProjection: "EPSG:4326",
         units: "m",
         numZoomLevels: 18,
         maxResolution: 156543.0339,
-        maxExtent: new OpenLayers.Bounds(-20037508, -20037508, 20037508, 20037508),
+        maxExtent: [-20037508, -20037508, 20037508, 20037508],
     });
 
     // create Google Mercator layers

From 76bb0be2542a3f60b94a88f76cbc0143a1068edc Mon Sep 17 00:00:00 2001
From: tschaub <tim.schaub@gmail.com>
Date: Tue, 8 Nov 2011 11:47:59 -0700
Subject: [PATCH 7/7] Spell projection with `p` and separate tests to avoid
 mock issues.

---
 lib/OpenLayers/Projection.js |  4 ++--
 tests/Projection.html        | 27 +++++++++++++++++++--------
 2 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/lib/OpenLayers/Projection.js b/lib/OpenLayers/Projection.js
index 97eb2f63ba..f30f679081 100644
--- a/lib/OpenLayers/Projection.js
+++ b/lib/OpenLayers/Projection.js
@@ -101,8 +101,8 @@ OpenLayers.Projection = OpenLayers.Class({
     equals: function(projection) {
         var p = projection, equals = false;
         if (p) {
-            if (!(projection instanceof OpenLayers.Projection)) {
-                projection = new OpenLayers.Projection(projection);
+            if (!(p instanceof OpenLayers.Projection)) {
+                p = new OpenLayers.Projection(p);
             }
             if (window.Proj4js && this.proj.defData && p.proj.defData) {
                 equals = this.proj.defData.replace(this.titleRegEx, "") ==
diff --git a/tests/Projection.html b/tests/Projection.html
index bb458b6f17..236871ab76 100644
--- a/tests/Projection.html
+++ b/tests/Projection.html
@@ -24,7 +24,7 @@
      }
      
      function test_Projection_equals(t) {
-         t.plan(12);
+         t.plan(8);
          var origTransforms = OpenLayers.Util.extend({}, OpenLayers.Projection.transforms);
          OpenLayers.Projection.addTransform("EPSG:4326", "FOO", OpenLayers.Projection.nullTransform);
          OpenLayers.Projection.addTransform("FOO", "EPSG:4326", OpenLayers.Projection.nullTransform);
@@ -57,16 +57,27 @@
          t.eq(proj1.equals(proj4), true, "EPSG:4326 and EPSG:4326 are equal with proj4js");
          t.eq(proj2.equals(proj5), false, "Projection.equals() returns false for unknown projections with proj4js");
          
-         // allow comparison with identifier
-         t.eq(proj1.equals("EPSG:4326"), true, "EPSG:4326 equality with string");
-         t.eq(proj1.equals("EPSG:4327"), false, "EPSG:4326 inequality with string");
-         t.eq(proj1.equals("EPSG:900913"), true, "EPSG:900913 equality with string");
-         t.eq(proj1.equals("EPSG:900914"), false, "EPSG:900913 inequality with string");
-         
          if (!hasProj) {
              window.Proj4js = undefined;
          }
-         
+
+    }
+    
+    function test_equals_string(t) {
+
+        t.plan(7);
+        var gg = new OpenLayers.Projection("EPSG:4326");
+        var sm = new OpenLayers.Projection("EPSG:900913");
+
+        // allow comparison with identifier
+        t.eq(gg.equals("EPSG:4326"), true, "EPSG:4326 equality with string");
+        t.eq(gg.equals("EPSG:4327"), false, "EPSG:4326 inequality with string");
+        t.eq(sm.equals("EPSG:900913"), true, "EPSG:900913 equality with string");
+        t.eq(sm.equals("EPSG:900914"), false, "EPSG:900913 inequality with string");
+        t.eq(sm.equals("EPSG:3857"), true, "EPSG:900913 equality with EPSG:3857");
+        t.eq(sm.equals("EPSG:102113"), true, "EPSG:900913 equality with EPSG:102113");
+        t.eq(sm.equals("EPSG:102100"), true, "EPSG:900913 equality with EPSG:102100");
+
      }
        
     </script>