diff --git a/build/license.txt b/build/license.txt
index dfc0d1dfa7..b74e2a79e7 100644
--- a/build/license.txt
+++ b/build/license.txt
@@ -52,3 +52,41 @@
  * You may obtain a copy of the License at
  * http://www.apache.org/licenses/LICENSE-2.0
  */
+
+/**
+ * Contains portions of Gears <http://code.google.com/apis/gears/>
+ *
+ * Copyright 2007, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. Neither the name of Google Inc. nor the names of its contributors may be
+ *     used to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Sets up google.gears.*, which is *the only* supported way to access Gears.
+ *
+ * Circumvent this file at your own risk!
+ *
+ * In the future, Gears may automatically define google.gears.* without this
+ * file. Gears may use these objects to transparently fix bugs and compatibility
+ * issues. Applications that use the code below will continue to work seamlessly
+ * when that happens.
+ */
diff --git a/examples/animator.js b/examples/animator.js
new file mode 100644
index 0000000000..abe540377b
--- /dev/null
+++ b/examples/animator.js
@@ -0,0 +1,670 @@
+/*  
+	Animator.js 1.1.9
+	
+	This library is released under the BSD license:
+
+	Copyright (c) 2006, Bernard Sumption. All rights reserved.
+	
+	Redistribution and use in source and binary forms, with or without
+	modification, are permitted provided that the following conditions are met:
+	
+	Redistributions of source code must retain the above copyright notice, this
+	list of conditions and the following disclaimer. Redistributions in binary
+	form must reproduce the above copyright notice, this list of conditions and
+	the following disclaimer in the documentation and/or other materials
+	provided with the distribution. Neither the name BernieCode nor
+	the names of its contributors may be used to endorse or promote products
+	derived from this software without specific prior written permission. 
+	
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+	AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+	ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+	ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+	DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+	CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+	LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+	OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+	DAMAGE.
+
+*/
+
+
+// Applies a sequence of numbers between 0 and 1 to a number of subjects
+// construct - see setOptions for parameters
+function Animator(options) {
+	this.setOptions(options);
+	var _this = this;
+	this.timerDelegate = function(){_this.onTimerEvent()};
+	this.subjects = [];
+	this.target = 0;
+	this.state = 0;
+	this.lastTime = null;
+};
+Animator.prototype = {
+	// apply defaults
+	setOptions: function(options) {
+		this.options = Animator.applyDefaults({
+			interval: 20,  // time between animation frames
+			duration: 400, // length of animation
+			onComplete: function(){},
+			onStep: function(){},
+			transition: Animator.tx.easeInOut
+		}, options);
+	},
+	// animate from the current state to provided value
+	seekTo: function(to) {
+		this.seekFromTo(this.state, to);
+	},
+	// animate from the current state to provided value
+	seekFromTo: function(from, to) {
+		this.target = Math.max(0, Math.min(1, to));
+		this.state = Math.max(0, Math.min(1, from));
+		this.lastTime = new Date().getTime();
+		if (!this.intervalId) {
+			this.intervalId = window.setInterval(this.timerDelegate, this.options.interval);
+		}
+	},
+	// animate from the current state to provided value
+	jumpTo: function(to) {
+		this.target = this.state = Math.max(0, Math.min(1, to));
+		this.propagate();
+	},
+	// seek to the opposite of the current target
+	toggle: function() {
+		this.seekTo(1 - this.target);
+	},
+	// add a function or an object with a method setState(state) that will be called with a number
+	// between 0 and 1 on each frame of the animation
+	addSubject: function(subject) {
+		this.subjects[this.subjects.length] = subject;
+		return this;
+	},
+	// remove all subjects
+	clearSubjects: function() {
+		this.subjects = [];
+	},
+	// forward the current state to the animation subjects
+	propagate: function() {
+		var value = this.options.transition(this.state);
+		for (var i=0; i<this.subjects.length; i++) {
+			if (this.subjects[i].setState) {
+				this.subjects[i].setState(value);
+			} else {
+				this.subjects[i](value);
+			}
+		}
+	},
+	// called once per frame to update the current state
+	onTimerEvent: function() {
+		var now = new Date().getTime();
+		var timePassed = now - this.lastTime;
+		this.lastTime = now;
+		var movement = (timePassed / this.options.duration) * (this.state < this.target ? 1 : -1);
+		if (Math.abs(movement) >= Math.abs(this.state - this.target)) {
+			this.state = this.target;
+		} else {
+			this.state += movement;
+		}
+		
+		try {
+			this.propagate();
+		} finally {
+			this.options.onStep.call(this);
+			if (this.target == this.state) {
+				window.clearInterval(this.intervalId);
+				this.intervalId = null;
+				this.options.onComplete.call(this);
+			}
+		}
+	},
+	// shortcuts
+	play: function() {this.seekFromTo(0, 1)},
+	reverse: function() {this.seekFromTo(1, 0)},
+	// return a string describing this Animator, for debugging
+	inspect: function() {
+		var str = "#<Animator:\n";
+		for (var i=0; i<this.subjects.length; i++) {
+			str += this.subjects[i].inspect();
+		}
+		str += ">";
+		return str;
+	}
+}
+// merge the properties of two objects
+Animator.applyDefaults = function(defaults, prefs) {
+	prefs = prefs || {};
+	var prop, result = {};
+	for (prop in defaults) result[prop] = prefs[prop] !== undefined ? prefs[prop] : defaults[prop];
+	return result;
+}
+// make an array from any object
+Animator.makeArray = function(o) {
+	if (o == null) return [];
+	if (!o.length) return [o];
+	var result = [];
+	for (var i=0; i<o.length; i++) result[i] = o[i];
+	return result;
+}
+// convert a dash-delimited-property to a camelCaseProperty (c/o Prototype, thanks Sam!)
+Animator.camelize = function(string) {
+	var oStringList = string.split('-');
+	if (oStringList.length == 1) return oStringList[0];
+	
+	var camelizedString = string.indexOf('-') == 0
+		? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1)
+		: oStringList[0];
+	
+	for (var i = 1, len = oStringList.length; i < len; i++) {
+		var s = oStringList[i];
+		camelizedString += s.charAt(0).toUpperCase() + s.substring(1);
+	}
+	return camelizedString;
+}
+// syntactic sugar for creating CSSStyleSubjects
+Animator.apply = function(el, style, options) {
+	if (style instanceof Array) {
+		return new Animator(options).addSubject(new CSSStyleSubject(el, style[0], style[1]));
+	}
+	return new Animator(options).addSubject(new CSSStyleSubject(el, style));
+}
+// make a transition function that gradually accelerates. pass a=1 for smooth
+// gravitational acceleration, higher values for an exaggerated effect
+Animator.makeEaseIn = function(a) {
+	return function(state) {
+		return Math.pow(state, a*2); 
+	}
+}
+// as makeEaseIn but for deceleration
+Animator.makeEaseOut = function(a) {
+	return function(state) {
+		return 1 - Math.pow(1 - state, a*2); 
+	}
+}
+// make a transition function that, like an object with momentum being attracted to a point,
+// goes past the target then returns
+Animator.makeElastic = function(bounces) {
+	return function(state) {
+		state = Animator.tx.easeInOut(state);
+		return ((1-Math.cos(state * Math.PI * bounces)) * (1 - state)) + state; 
+	}
+}
+// make an Attack Decay Sustain Release envelope that starts and finishes on the same level
+// 
+Animator.makeADSR = function(attackEnd, decayEnd, sustainEnd, sustainLevel) {
+	if (sustainLevel == null) sustainLevel = 0.5;
+	return function(state) {
+		if (state < attackEnd) {
+			return state / attackEnd;
+		}
+		if (state < decayEnd) {
+			return 1 - ((state - attackEnd) / (decayEnd - attackEnd) * (1 - sustainLevel));
+		}
+		if (state < sustainEnd) {
+			return sustainLevel;
+		}
+		return sustainLevel * (1 - ((state - sustainEnd) / (1 - sustainEnd)));
+	}
+}
+// make a transition function that, like a ball falling to floor, reaches the target and/
+// bounces back again
+Animator.makeBounce = function(bounces) {
+	var fn = Animator.makeElastic(bounces);
+	return function(state) {
+		state = fn(state); 
+		return state <= 1 ? state : 2-state;
+	}
+}
+ 
+// pre-made transition functions to use with the 'transition' option
+Animator.tx = {
+	easeInOut: function(pos){
+		return ((-Math.cos(pos*Math.PI)/2) + 0.5);
+	},
+	linear: function(x) {
+		return x;
+	},
+	easeIn: Animator.makeEaseIn(1.5),
+	easeOut: Animator.makeEaseOut(1.5),
+	strongEaseIn: Animator.makeEaseIn(2.5),
+	strongEaseOut: Animator.makeEaseOut(2.5),
+	elastic: Animator.makeElastic(1),
+	veryElastic: Animator.makeElastic(3),
+	bouncy: Animator.makeBounce(1),
+	veryBouncy: Animator.makeBounce(3)
+}
+
+// animates a pixel-based style property between two integer values
+function NumericalStyleSubject(els, property, from, to, units) {
+	this.els = Animator.makeArray(els);
+	if (property == 'opacity' && window.ActiveXObject) {
+		this.property = 'filter';
+	} else {
+		this.property = Animator.camelize(property);
+	}
+	this.from = parseFloat(from);
+	this.to = parseFloat(to);
+	this.units = units != null ? units : 'px';
+}
+NumericalStyleSubject.prototype = {
+	setState: function(state) {
+		var style = this.getStyle(state);
+		var visibility = (this.property == 'opacity' && state == 0) ? 'hidden' : '';
+		var j=0;
+		for (var i=0; i<this.els.length; i++) {
+			try {
+				this.els[i].style[this.property] = style;
+			} catch (e) {
+				// ignore fontWeight - intermediate numerical values cause exeptions in firefox
+				if (this.property != 'fontWeight') throw e;
+			}
+			if (j++ > 20) return;
+		}
+	},
+	getStyle: function(state) {
+		state = this.from + ((this.to - this.from) * state);
+		if (this.property == 'filter') return "alpha(opacity=" + Math.round(state*100) + ")";
+		if (this.property == 'opacity') return state;
+		return Math.round(state) + this.units;
+	},
+	inspect: function() {
+		return "\t" + this.property + "(" + this.from + this.units + " to " + this.to + this.units + ")\n";
+	}
+}
+
+// animates a colour based style property between two hex values
+function ColorStyleSubject(els, property, from, to) {
+	this.els = Animator.makeArray(els);
+	this.property = Animator.camelize(property);
+	this.to = this.expandColor(to);
+	this.from = this.expandColor(from);
+	this.origFrom = from;
+	this.origTo = to;
+}
+
+ColorStyleSubject.prototype = {
+	// parse "#FFFF00" to [256, 256, 0]
+	expandColor: function(color) {
+		var hexColor, red, green, blue;
+		hexColor = ColorStyleSubject.parseColor(color);
+		if (hexColor) {
+			red = parseInt(hexColor.slice(1, 3), 16);
+			green = parseInt(hexColor.slice(3, 5), 16);
+			blue = parseInt(hexColor.slice(5, 7), 16);
+			return [red,green,blue]
+		}
+		if (window.DEBUG) {
+			alert("Invalid colour: '" + color + "'");
+		}
+	},
+	getValueForState: function(color, state) {
+		return Math.round(this.from[color] + ((this.to[color] - this.from[color]) * state));
+	},
+	setState: function(state) {
+		var color = '#'
+				+ ColorStyleSubject.toColorPart(this.getValueForState(0, state))
+				+ ColorStyleSubject.toColorPart(this.getValueForState(1, state))
+				+ ColorStyleSubject.toColorPart(this.getValueForState(2, state));
+		for (var i=0; i<this.els.length; i++) {
+			this.els[i].style[this.property] = color;
+		}
+	},
+	inspect: function() {
+		return "\t" + this.property + "(" + this.origFrom + " to " + this.origTo + ")\n";
+	}
+}
+
+// return a properly formatted 6-digit hex colour spec, or false
+ColorStyleSubject.parseColor = function(string) {
+	var color = '#', match;
+	if(match = ColorStyleSubject.parseColor.rgbRe.exec(string)) {
+		var part;
+		for (var i=1; i<=3; i++) {
+			part = Math.max(0, Math.min(255, parseInt(match[i])));
+			color += ColorStyleSubject.toColorPart(part);
+		}
+		return color;
+	}
+	if (match = ColorStyleSubject.parseColor.hexRe.exec(string)) {
+		if(match[1].length == 3) {
+			for (var i=0; i<3; i++) {
+				color += match[1].charAt(i) + match[1].charAt(i);
+			}
+			return color;
+		}
+		return '#' + match[1];
+	}
+	return false;
+}
+// convert a number to a 2 digit hex string
+ColorStyleSubject.toColorPart = function(number) {
+	if (number > 255) number = 255;
+	var digits = number.toString(16);
+	if (number < 16) return '0' + digits;
+	return digits;
+}
+ColorStyleSubject.parseColor.rgbRe = /^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i;
+ColorStyleSubject.parseColor.hexRe = /^\#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+
+// Animates discrete styles, i.e. ones that do not scale but have discrete values
+// that can't be interpolated
+function DiscreteStyleSubject(els, property, from, to, threshold) {
+	this.els = Animator.makeArray(els);
+	this.property = Animator.camelize(property);
+	this.from = from;
+	this.to = to;
+	this.threshold = threshold || 0.5;
+}
+
+DiscreteStyleSubject.prototype = {
+	setState: function(state) {
+		var j=0;
+		for (var i=0; i<this.els.length; i++) {
+			this.els[i].style[this.property] = state <= this.threshold ? this.from : this.to; 
+		}
+	},
+	inspect: function() {
+		return "\t" + this.property + "(" + this.from + " to " + this.to + " @ " + this.threshold + ")\n";
+	}
+}
+
+// animates between two styles defined using CSS.
+// if style1 and style2 are present, animate between them, if only style1
+// is present, animate between the element's current style and style1
+function CSSStyleSubject(els, style1, style2) {
+	els = Animator.makeArray(els);
+	this.subjects = [];
+	if (els.length == 0) return;
+	var prop, toStyle, fromStyle;
+	if (style2) {
+		fromStyle = this.parseStyle(style1, els[0]);
+		toStyle = this.parseStyle(style2, els[0]);
+	} else {
+		toStyle = this.parseStyle(style1, els[0]);
+		fromStyle = {};
+		for (prop in toStyle) {
+			fromStyle[prop] = CSSStyleSubject.getStyle(els[0], prop);
+		}
+	}
+	// remove unchanging properties
+	var prop;
+	for (prop in fromStyle) {
+		if (fromStyle[prop] == toStyle[prop]) {
+			delete fromStyle[prop];
+			delete toStyle[prop];
+		}
+	}
+	// discover the type (numerical or colour) of each style
+	var prop, units, match, type, from, to;
+	for (prop in fromStyle) {
+		var fromProp = String(fromStyle[prop]);
+		var toProp = String(toStyle[prop]);
+		if (toStyle[prop] == null) {
+			if (window.DEBUG) alert("No to style provided for '" + prop + '"');
+			continue;
+		}
+		
+		if (from = ColorStyleSubject.parseColor(fromProp)) {
+			to = ColorStyleSubject.parseColor(toProp);
+			type = ColorStyleSubject;
+		} else if (fromProp.match(CSSStyleSubject.numericalRe)
+				&& toProp.match(CSSStyleSubject.numericalRe)) {
+			from = parseFloat(fromProp);
+			to = parseFloat(toProp);
+			type = NumericalStyleSubject;
+			match = CSSStyleSubject.numericalRe.exec(fromProp);
+			var reResult = CSSStyleSubject.numericalRe.exec(toProp);
+			if (match[1] != null) {
+				units = match[1];
+			} else if (reResult[1] != null) {
+				units = reResult[1];
+			} else {
+				units = reResult;
+			}
+		} else if (fromProp.match(CSSStyleSubject.discreteRe)
+				&& toProp.match(CSSStyleSubject.discreteRe)) {
+			from = fromProp;
+			to = toProp;
+			type = DiscreteStyleSubject;
+			units = 0;   // hack - how to get an animator option down to here
+		} else {
+			if (window.DEBUG) {
+				alert("Unrecognised format for value of "
+					+ prop + ": '" + fromStyle[prop] + "'");
+			}
+			continue;
+		}
+		this.subjects[this.subjects.length] = new type(els, prop, from, to, units);
+	}
+}
+
+CSSStyleSubject.prototype = {
+	// parses "width: 400px; color: #FFBB2E" to {width: "400px", color: "#FFBB2E"}
+	parseStyle: function(style, el) {
+		var rtn = {};
+		// if style is a rule set
+		if (style.indexOf(":") != -1) {
+			var styles = style.split(";");
+			for (var i=0; i<styles.length; i++) {
+				var parts = CSSStyleSubject.ruleRe.exec(styles[i]);
+				if (parts) {
+					rtn[parts[1]] = parts[2];
+				}
+			}
+		}
+		// else assume style is a class name
+		else {
+			var prop, value, oldClass;
+			oldClass = el.className;
+			el.className = style;
+			for (var i=0; i<CSSStyleSubject.cssProperties.length; i++) {
+				prop = CSSStyleSubject.cssProperties[i];
+				value = CSSStyleSubject.getStyle(el, prop);
+				if (value != null) {
+					rtn[prop] = value;
+				}
+			}
+			el.className = oldClass;
+		}
+		return rtn;
+		
+	},
+	setState: function(state) {
+		for (var i=0; i<this.subjects.length; i++) {
+			this.subjects[i].setState(state);
+		}
+	},
+	inspect: function() {
+		var str = "";
+		for (var i=0; i<this.subjects.length; i++) {
+			str += this.subjects[i].inspect();
+		}
+		return str;
+	}
+}
+// get the current value of a css property, 
+CSSStyleSubject.getStyle = function(el, property){
+	var style;
+	if(document.defaultView && document.defaultView.getComputedStyle){
+		style = document.defaultView.getComputedStyle(el, "").getPropertyValue(property);
+		if (style) {
+			return style;
+		}
+	}
+	property = Animator.camelize(property);
+	if(el.currentStyle){
+		style = el.currentStyle[property];
+	}
+	return style || el.style[property]
+}
+
+
+CSSStyleSubject.ruleRe = /^\s*([a-zA-Z\-]+)\s*:\s*(\S(.+\S)?)\s*$/;
+CSSStyleSubject.numericalRe = /^-?\d+(?:\.\d+)?(%|[a-zA-Z]{2})?$/;
+CSSStyleSubject.discreteRe = /^\w+$/;
+
+// required because the style object of elements isn't enumerable in Safari
+/*
+CSSStyleSubject.cssProperties = ['background-color','border','border-color','border-spacing',
+'border-style','border-top','border-right','border-bottom','border-left','border-top-color',
+'border-right-color','border-bottom-color','border-left-color','border-top-width','border-right-width',
+'border-bottom-width','border-left-width','border-width','bottom','color','font-size','font-size-adjust',
+'font-stretch','font-style','height','left','letter-spacing','line-height','margin','margin-top',
+'margin-right','margin-bottom','margin-left','marker-offset','max-height','max-width','min-height',
+'min-width','orphans','outline','outline-color','outline-style','outline-width','overflow','padding',
+'padding-top','padding-right','padding-bottom','padding-left','quotes','right','size','text-indent',
+'top','width','word-spacing','z-index','opacity','outline-offset'];*/
+
+
+CSSStyleSubject.cssProperties = ['azimuth','background','background-attachment','background-color','background-image','background-position','background-repeat','border-collapse','border-color','border-spacing','border-style','border-top','border-top-color','border-right-color','border-bottom-color','border-left-color','border-top-style','border-right-style','border-bottom-style','border-left-style','border-top-width','border-right-width','border-bottom-width','border-left-width','border-width','bottom','clear','clip','color','content','cursor','direction','display','elevation','empty-cells','css-float','font','font-family','font-size','font-size-adjust','font-stretch','font-style','font-variant','font-weight','height','left','letter-spacing','line-height','list-style','list-style-image','list-style-position','list-style-type','margin','margin-top','margin-right','margin-bottom','margin-left','max-height','max-width','min-height','min-width','orphans','outline','outline-color','outline-style','outline-width','overflow','padding','padding-top','padding-right','padding-bottom','padding-left','pause','position','right','size','table-layout','text-align','text-decoration','text-indent','text-shadow','text-transform','top','vertical-align','visibility','white-space','width','word-spacing','z-index','opacity','outline-offset','overflow-x','overflow-y'];
+
+
+// chains several Animator objects together
+function AnimatorChain(animators, options) {
+	this.animators = animators;
+	this.setOptions(options);
+	for (var i=0; i<this.animators.length; i++) {
+		this.listenTo(this.animators[i]);
+	}
+	this.forwards = false;
+	this.current = 0;
+}
+
+AnimatorChain.prototype = {
+	// apply defaults
+	setOptions: function(options) {
+		this.options = Animator.applyDefaults({
+			// by default, each call to AnimatorChain.play() calls jumpTo(0) of each animator
+			// before playing, which can cause flickering if you have multiple animators all
+			// targeting the same element. Set this to false to avoid this.
+			resetOnPlay: true
+		}, options);
+	},
+	// play each animator in turn
+	play: function() {
+		this.forwards = true;
+		this.current = -1;
+		if (this.options.resetOnPlay) {
+			for (var i=0; i<this.animators.length; i++) {
+				this.animators[i].jumpTo(0);
+			}
+		}
+		this.advance();
+	},
+	// play all animators backwards
+	reverse: function() {
+		this.forwards = false;
+		this.current = this.animators.length;
+		if (this.options.resetOnPlay) {
+			for (var i=0; i<this.animators.length; i++) {
+				this.animators[i].jumpTo(1);
+			}
+		}
+		this.advance();
+	},
+	// if we have just play()'d, then call reverse(), and vice versa
+	toggle: function() {
+		if (this.forwards) {
+			this.seekTo(0);
+		} else {
+			this.seekTo(1);
+		}
+	},
+	// internal: install an event listener on an animator's onComplete option
+	// to trigger the next animator
+	listenTo: function(animator) {
+		var oldOnComplete = animator.options.onComplete;
+		var _this = this;
+		animator.options.onComplete = function() {
+			if (oldOnComplete) oldOnComplete.call(animator);
+			_this.advance();
+		}
+	},
+	// play the next animator
+	advance: function() {
+		if (this.forwards) {
+			if (this.animators[this.current + 1] == null) return;
+			this.current++;
+			this.animators[this.current].play();
+		} else {
+			if (this.animators[this.current - 1] == null) return;
+			this.current--;
+			this.animators[this.current].reverse();
+		}
+	},
+	// this function is provided for drop-in compatibility with Animator objects,
+	// but only accepts 0 and 1 as target values
+	seekTo: function(target) {
+		if (target <= 0) {
+			this.forwards = false;
+			this.animators[this.current].seekTo(0);
+		} else {
+			this.forwards = true;
+			this.animators[this.current].seekTo(1);
+		}
+	}
+}
+
+// an Accordion is a class that creates and controls a number of Animators. An array of elements is passed in,
+// and for each element an Animator and a activator button is created. When an Animator's activator button is
+// clicked, the Animator and all before it seek to 0, and all Animators after it seek to 1. This can be used to
+// create the classic Accordion effect, hence the name.
+// see setOptions for arguments
+function Accordion(options) {
+	this.setOptions(options);
+	var selected = this.options.initialSection, current;
+	if (this.options.rememberance) {
+		current = document.location.hash.substring(1);
+	}
+	this.rememberanceTexts = [];
+	this.ans = [];
+	var _this = this;
+	for (var i=0; i<this.options.sections.length; i++) {
+		var el = this.options.sections[i];
+		var an = new Animator(this.options.animatorOptions);
+		var from = this.options.from + (this.options.shift * i);
+		var to = this.options.to + (this.options.shift * i);
+		an.addSubject(new NumericalStyleSubject(el, this.options.property, from, to, this.options.units));
+		an.jumpTo(0);
+		var activator = this.options.getActivator(el);
+		activator.index = i;
+		activator.onclick = function(){_this.show(this.index)};
+		this.ans[this.ans.length] = an;
+		this.rememberanceTexts[i] = activator.innerHTML.replace(/\s/g, "");
+		if (this.rememberanceTexts[i] === current) {
+			selected = i;
+		}
+	}
+	this.show(selected);
+}
+
+Accordion.prototype = {
+	// apply defaults
+	setOptions: function(options) {
+		this.options = Object.extend({
+			// REQUIRED: an array of elements to use as the accordion sections
+			sections: null,
+			// a function that locates an activator button element given a section element.
+			// by default it takes a button id from the section's "activator" attibute
+			getActivator: function(el) {return document.getElementById(el.getAttribute("activator"))},
+			// shifts each animator's range, for example with options {from:0,to:100,shift:20}
+			// the animators' ranges will be 0-100, 20-120, 40-140 etc.
+			shift: 0,
+			// the first page to show
+			initialSection: 0,
+			// if set to true, document.location.hash will be used to preserve the open section across page reloads 
+			rememberance: true,
+			// constructor arguments to the Animator objects
+			animatorOptions: {}
+		}, options || {});
+	},
+	show: function(section) {
+		for (var i=0; i<this.ans.length; i++) {
+			this.ans[i].seekTo(i > section ? 1 : 0);
+		}
+		if (this.options.rememberance) {
+			document.location.hash = this.rememberanceTexts[section];
+		}
+	}
+}
diff --git a/examples/measure.html b/examples/measure.html
index 94bc4000e1..71aaee20b9 100644
--- a/examples/measure.html
+++ b/examples/measure.html
@@ -92,6 +92,31 @@
             
             document.getElementById('noneToggle').checked = true;
         }
+
+        function calcVincenty(geometry) {
+            /**
+             * Note: this function assumes geographic coordinates and
+             *     will fail otherwise.  OpenLayers.Util.distVincenty takes
+             *     two objects representing points with geographic coordinates
+             *     and returns the geodesic distance between them (shortest
+             *     distance between the two points on an ellipsoid) in *kilometers*.
+             *
+             * It is important to realize that the segments drawn on the map
+             *     are *not* geodesics (or "great circle" segments).  This means
+             *     that in general, the measure returned by this function
+             *     will not represent the length of segments drawn on the map.
+             */
+            var dist = 0;
+            for (var i = 1; i < geometry.components.length; i++) {
+                var first = geometry.components[i-1];
+                var second = geometry.components[i];
+                dist += OpenLayers.Util.distVincenty(
+                    {lon: first.x, lat: first.y},
+                    {lon: second.x, lat: second.y}
+                );
+            }
+            return dist;
+        }    
         
         function handleMeasurements(event) {
             var geometry = event.geometry;
@@ -102,6 +127,10 @@
             var out = "";
             if(order == 1) {
                 out += "measure: " + measure.toFixed(3) + " " + units;
+                if (map.getProjection() == "EPSG:4326") {
+                    out += "<br /> Great Circle Distance: " + 
+                        calcVincenty(geometry).toFixed(3) + " km *"; 
+                }        
             } else {
                 out += "measure: " + measure.toFixed(3) + " " + units + "<sup>2</" + "sup>";
             }
@@ -144,6 +173,12 @@
                 <label for="polygonToggle">measure area</label>
             </li>
         </ul>
+        <p>* Note that the geometries drawn are planar geometries and the
+        metrics returned by the measure control are planar measures.  The
+        "great circle" distance does not necessarily represent the length
+        of the segments drawn on the map.  Instead, it is a geodesic metric that
+        represents the cumulative shortest path between all vertices in the
+        geometry were they projected onto a sphere.</p>
     </div>
   </body>
 </html>
diff --git a/examples/protocol-gears.html b/examples/protocol-gears.html
new file mode 100644
index 0000000000..6bbfb5f030
--- /dev/null
+++ b/examples/protocol-gears.html
@@ -0,0 +1,261 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <link rel="stylesheet" href="../theme/default/style.css" type="text/css" />
+    <link rel="stylesheet" href="style.css" type="text/css" />
+    <style type="text/css">
+        .float-left {
+            float: left;
+        }
+        .clear-left {
+            clear: left;
+        }
+    </style>
+    <script src="../lib/OpenLayers.js"></script>
+    <script type="text/javascript">
+        var map, vector, protocol, modify;
+
+        function init() {
+            // create Gears protocol
+            protocol = new OpenLayers.Protocol.SQL.Gears({
+                databaseName: "db_name",
+                tableName: "table_name",
+                saveFeatureState: false
+            });
+
+            if (!GearsIsSupported()) {
+                return;
+            }
+
+            map = new OpenLayers.Map("map");
+
+            // create base layer
+            var layer = new OpenLayers.Layer.WMS("OpenLayers WMS",
+                "http://labs.metacarta.com/wms/vmap0",
+                {"layers": "basic"}
+            );
+            map.addLayer(layer);
+
+            // create vector layer
+            vector = new OpenLayers.Layer.Vector("Vector", {
+                protocol: protocol,
+                strategies : [new OpenLayers.Strategy.Fixed()],
+                eventListeners: {
+                    featuremodified: function(obj) {
+                        if (obj.feature.state != OpenLayers.State.INSERT &&
+                            obj.feature.state != OpenLayers.State.DELETE) {
+
+                            obj.feature.state = OpenLayers.State.UPDATE;
+                        }
+                        displayStatus();
+                    }
+                }
+            });
+            map.addLayer(vector);
+
+            // create modify feature control
+            modify = new OpenLayers.Control.ModifyFeature(vector);
+
+            // create editing panel
+            var panel = new OpenLayers.Control.Panel({
+                displayClass: "olControlEditingToolbar"
+            });
+
+            var navigation = new OpenLayers.Control.Navigation({
+                eventListeners: {
+                    activate: function(obj) {
+                        modify.activate();
+                    },
+                    deactivate: function(obj) {
+                        modify.deactivate();
+                    }
+                }
+            });
+
+            var editing = new OpenLayers.Control.DrawFeature(
+                vector, OpenLayers.Handler.Polygon, {
+                displayClass: "olControlDrawFeaturePolygon",
+                eventListeners: {
+                    featureadded: function(obj) {
+                        obj.feature.state = OpenLayers.State.INSERT;
+                        displayStatus();
+                    }
+                }
+            });
+            panel.addControls([navigation, editing]);
+            panel.defaultControl = navigation;
+
+            // add controls to the map
+            map.addControl(modify);
+            map.addControl(panel);
+
+            // center the map
+            map.setCenter(new OpenLayers.LonLat(5, 40), 5);
+        }
+
+        function displayResult(txt) {
+            if (window.resultDomElement === undefined) {
+                window.resultDomElement = OpenLayers.Util.getElement("last-result");
+            }
+            resultDomElement.innerHTML = txt;
+            displayStatus();
+        }
+
+        function displayStatus() {
+            if (window.statusDomElement === undefined) {
+                window.statusDomElement = OpenLayers.Util.getElement("status");
+            }
+
+            var createCnt = 0;
+            var updateCnt = 0;
+            var deleteCnt = 0;
+            var i, len, state;
+            for (i = 0, len = vector.features.length; i < len; i++) {
+                state = vector.features[i].state;
+                if (state == OpenLayers.State.INSERT) {
+                    createCnt++;
+                } else if (state == OpenLayers.State.UPDATE) {
+                    updateCnt++;
+                } else if (state == OpenLayers.State.DELETE) {
+                    deleteCnt++;
+                }
+            }
+            statusDomElement.innerHTML = createCnt + " features to create, " +
+                                         updateCnt + " features to update, " +
+                                         deleteCnt + " features to delete";
+        }
+
+        function GearsIsSupported() {
+            if (!protocol.supported()) {
+                OpenLayers.Console.userError("You must install Gears prior to using this example");
+                return false;
+            }
+            return true;
+        }
+
+        function featuresWithState(state) {
+            var list = [];
+            var i, len, feature;
+            for (i = 0, len = vector.features.length; i < len; i++) {
+                feature = vector.features[i];
+                if (feature.state == state) {
+                    list.push(feature);
+                }
+            }
+            return list;
+        }
+
+        function _sync() {
+            if (!GearsIsSupported()) {
+                return;
+            }
+            var resp = protocol.read();
+            if (!resp.success()) {
+                OpenLayers.Console.error("reading from Gears DB failed");
+                return;
+            }
+            vector.destroyFeatures();
+            if (!resp.features || resp.features.length <= 0) {
+                displayResult("No features to read");
+                return;
+            }
+            vector.addFeatures(resp.features);
+            displayResult("features successfully read");
+        }
+
+        function _commit() {
+            if (!GearsIsSupported()) {
+                return;
+            }
+            var error = false;
+            function callback(resp) {
+                if (error) {
+                    return;
+                }
+                if (!resp.success()) {
+                    OpenLayers.Console.error("Commiting to Gears DB failed");
+                    error = true;
+                    return;
+                }
+                modify.selectControl.unselectAll()
+
+                if (resp.reqFeatures) {
+                    vector.destroyFeatures(resp.reqFeatures);
+                }
+                if (resp.features) {
+                    vector.addFeatures(resp.features);
+                }
+            }
+            if (vector.features.length > 0) {
+                protocol.commit(vector.features, {
+                    "create": {
+                        callback: callback
+                    },
+                    "update": {
+                        callback: callback
+                    },
+                    "delete": {
+                        callback: callback
+                    }
+                });
+                if (!error) {
+                    displayResult("features successfully committed");
+                }
+            } else {
+                displayResult("no features to commit");
+            }
+        }
+
+        function _delete() {
+            if (!GearsIsSupported()) {
+                return;
+            }
+            var feature = vector.selectedFeatures[0];
+            if (feature) {
+                modify.selectControl.unselectAll()
+                feature.state = OpenLayers.State.DELETE;
+                displayStatus();
+            }
+        }
+    </script>
+  </head>
+  <body onload="init()">
+    <h1 id="title">Gears Protocol Example</h1>
+
+    <div id="tags">
+    </div>
+    <p id="shortdesc">
+        Shows the usage of the Gears protocol.
+    </p>
+
+    <div class="float-left">
+      <div id="map" class="smallmap"></div>
+    </div>
+
+    <div>
+      <a href="javascript:_sync()">Sync</a>
+      <p>The Sync link destroys the features currently in the layer, reads
+         features from the Gears database, and adds them to the layer.
+         Uncommitted features will be lost.</p>
+
+      <a href="javascript:_commit()">Commit</a>
+      <p>The Commit link commits to the Gears database the features that are
+         marked as INSERT, UPDATE or DELETE.</p>
+
+      <a href="javascript:_delete()">Delete</a>
+      <p>The Delete link marks the selected feature as DELETE. To select a feature
+         click choose the navigation control in the editing toolbar.</p>
+    </div>
+
+    <div style="margin-top: 30px">
+      <p>Status: <span id="status"></span></p>
+      <p>Result: <span id="last-result"></span></p>
+    </div>
+
+    <div class="clear-left" id="docs">
+      <p>This example demonstrates the usage of OpenLayers Gears protocol to
+         read/create/update/delete features from/to the Gears database.
+         <a href="http://gears.google.com/">Gears</a> must obviously be installed
+         in your browser for this example to work.</p>
+    </div>
+  </body>
+</html>
diff --git a/examples/proxy.cgi b/examples/proxy.cgi
index a3f78be57a..af5c3b8038 100755
--- a/examples/proxy.cgi
+++ b/examples/proxy.cgi
@@ -18,7 +18,7 @@ import sys, os
 allowedHosts = ['www.openlayers.org', 'openlayers.org', 
                 'labs.metacarta.com', 'world.freemap.in', 
                 'prototype.openmnnd.org', 'geo.openplans.org',
-                'sigma.openplans.org'
+                'sigma.openplans.org',
                 'www.openstreetmap.org']
 
 method = os.environ["REQUEST_METHOD"]
@@ -40,8 +40,8 @@ try:
         print "Status: 502 Bad Gateway"
         print "Content-Type: text/plain"
         print
-        print "This proxy does not allow you to access that location."
-        print 
+        print "This proxy does not allow you to access that location (%s)." % (host,)
+        print
         print os.environ
   
     elif url.startswith("http://") or url.startswith("https://"):
diff --git a/examples/spherical-mercator.html b/examples/spherical-mercator.html
index c4ded648a8..cc4da86752 100644
--- a/examples/spherical-mercator.html
+++ b/examples/spherical-mercator.html
@@ -28,6 +28,7 @@
                 projection: new OpenLayers.Projection("EPSG:900913"),
                 displayProjection: new OpenLayers.Projection("EPSG:4326"),
                 units: "m",
+                numZoomLevels: 18,
                 maxResolution: 156543.0339,
                 maxExtent: new OpenLayers.Bounds(-20037508, -20037508,
                                                  20037508, 20037508.34)
@@ -86,8 +87,8 @@
                     attribution: '<a href="http://www.openstreetmap.org/">OpenStreetMap</a>'
                 }
             );
-            // create OSM layer
-            var mapnik = new OpenLayers.Layer.TMS(
+            // create OAM layer
+            var oam = new OpenLayers.Layer.TMS(
                 "OpenAerialMap",
                 "http://tile.openaerialmap.org/tiles/1.0.0/openaerialmap-900913/",
                 {
@@ -95,10 +96,20 @@
                 }
             );
 
+            // create OSM layer
+            var mapnik = new OpenLayers.Layer.TMS(
+                "OpenStreetMap (Mapnik)",
+                  "http://a.tile.openstreetmap.org/",
+                {
+                    type: 'png', getURL: osm_getTileURL,
+                    displayOutsideMaxExtent: true,
+                    attribution: '<a href="http://www.openstreetmap.org/">OpenStreetMap</a>'
+                }
+            );
             // create OSM layer
             var osmarender = new OpenLayers.Layer.TMS(
                 "OpenStreetMap (Tiles@Home)",
-                "http://tah.openstreetmap.org/Tiles/tile.php/",
+                "http://tah.openstreetmap.org/Tiles/tile/",
                 {
                     type: 'png', getURL: osm_getTileURL,
                     displayOutsideMaxExtent: true,
@@ -122,7 +133,7 @@
             var vector = new OpenLayers.Layer.Vector("Editable Vectors");
 
             map.addLayers([gmap, gsat, ghyb, veroad, veaer, vehyb,
-                           yahoo, yahoosat, yahoohyb, mapnik, osmarender,
+                           yahoo, yahoosat, yahoohyb, oam, mapnik, osmarender,
                            wms, vector]);
             map.addControl(new OpenLayers.Control.LayerSwitcher());
             map.addControl(new OpenLayers.Control.EditingToolbar(vector));
diff --git a/examples/strategy-bbox.html b/examples/strategy-bbox.html
new file mode 100644
index 0000000000..173d33f1f7
--- /dev/null
+++ b/examples/strategy-bbox.html
@@ -0,0 +1,64 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+    <head>
+        <title>OpenLayers BBOX Strategy Example</title>
+        <link rel="stylesheet" href="../theme/default/style.css" type="text/css" />
+        <link rel="stylesheet" href="style.css" type="text/css" />
+        <script src="../lib/OpenLayers.js"></script>
+        <script type="text/javascript">
+            var map, photos;
+            OpenLayers.ProxyHost = (window.location.host == "localhost") ?
+                "/cgi-bin/proxy.cgi?url=" : "proxy.cgi?url=";
+        
+            function init() {
+                map = new OpenLayers.Map('map', {
+                    restrictedExtent: new OpenLayers.Bounds(-180, -90, 180, 90)
+                });
+                var base = new OpenLayers.Layer.WMS("OpenLayers WMS", 
+                    ["http://t3.labs.metacarta.com/wms-c/Basic.py",
+                     "http://t2.labs.metacarta.com/wms-c/Basic.py",
+                     "http://t1.labs.metacarta.com/wms-c/Basic.py"], 
+                    {layers: 'satellite'}
+                );
+
+                var style = new OpenLayers.Style({
+                    externalGraphic: "${img_url}",
+                    pointRadius: 30
+                });
+
+                photos = new OpenLayers.Layer.Vector("Photos", {
+                    strategies: [new OpenLayers.Strategy.BBOX()],
+                    protocol: new OpenLayers.Protocol.HTTP({
+                        url: "http://labs.metacarta.com/flickrbrowse/flickr.py/flickr",
+                        params: {
+                            format: "WFS",
+                            sort: "interestingness-desc",
+                            service: "WFS",
+                            request: "GetFeatures",
+                            srs: "EPSG:4326",
+                            maxfeatures: 10
+                        },
+                        format: new OpenLayers.Format.GML()
+                    }),
+                    styleMap: new OpenLayers.StyleMap(style)
+                });
+
+                map.addLayers([base, photos]);
+                map.setCenter(new OpenLayers.LonLat(-116.45, 35.42), 5);
+            }
+            
+        </script>
+    </head>
+    <body onload="init()">
+        <h1 id="title">BBOX Strategy Example</h1>
+        <p id="shortdesc">
+            Uses a BBOX strategy to request features within a bounding box.
+        </p>
+        <div id="map" class="smallmap"></div>
+        <div id="docs">
+            <p>The BBOX strategy requests data within a bounding box.  When the
+            previously requested data bounds are invalidated (by browsing to
+            some area not covered by those bounds), another request for data
+            is issued.</p>
+        </div>
+    </body>
+</html>
diff --git a/examples/strategy-cluster.html b/examples/strategy-cluster.html
new file mode 100644
index 0000000000..91e1e428cd
--- /dev/null
+++ b/examples/strategy-cluster.html
@@ -0,0 +1,201 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+    <head>
+        <title>OpenLayers Cluster Strategy Example</title>
+        <link rel="stylesheet" href="../theme/default/style.css" type="text/css" />
+        <link rel="stylesheet" href="style.css" type="text/css" />
+        <style type="text/css">
+            #photos {
+                height: 100px;
+                width: 512px;
+                position: relative;
+                white-space: nowrap;
+            }
+            .shift {
+                height: 25px;
+                line-height: 25px;
+                background-color: #fefefe;
+                text-align: center;
+                position: absolute;
+                bottom: 10px;
+                font-size: 8px;
+                font-weight: bold;
+                color: #696969;
+                width: 25px;
+            }
+            #scroll-start {
+                left: 0px;
+            }
+            #scroll-end {
+                right: 0px;
+            }
+            #scroll {
+                left: 30px;
+                width: 452px;
+                height: 100px;
+                overflow: hidden;
+                position: absolute;
+                bottom: 0px;
+            }
+            #photos ul {
+                position: absolute;
+                bottom: 0px;
+                padding: 0;
+                margin: 0;
+            }
+            #photos ul.start {
+                left: 0px;
+            }
+            #photos ul.end {
+                right: 80px;
+            }
+            #photos ul li {
+                padding 10px;
+                margin: 0;
+                list-style: none;
+                display: inline;
+            }
+            img.thumb {
+                height: 30px;
+            }
+            img.big {
+                height: 90px;
+            }
+        </style>
+        <script src="../lib/OpenLayers.js"></script>
+        <script src="Jugl.js"></script>
+        <script src="animator.js"></script>
+        <script type="text/javascript">
+            var map, template;
+            var Jugl = window["http://jugl.tschaub.net/trunk/lib/Jugl.js"];
+            OpenLayers.ProxyHost = (window.location.host == "localhost") ?
+                "/cgi-bin/proxy.cgi?url=" : "proxy.cgi?url=";
+
+            function init() {
+                map = new OpenLayers.Map('map', {
+                    restrictedExtent: new OpenLayers.Bounds(-180, -90, 180, 90)
+                });
+                var base = new OpenLayers.Layer.WMS("OpenLayers WMS", 
+                    ["http://t3.labs.metacarta.com/wms-c/Basic.py",
+                     "http://t2.labs.metacarta.com/wms-c/Basic.py",
+                     "http://t1.labs.metacarta.com/wms-c/Basic.py"], 
+                    {layers: 'satellite'}
+                );
+
+                var style = new OpenLayers.Style({
+                    pointRadius: "${radius}",
+                    fillColor: "#ffcc66",
+                    fillOpacity: 0.8,
+                    strokeColor: "#cc6633",
+                    strokeWidth: 2,
+                    strokeOpacity: 0.8
+                }, {
+                    context: {
+                        radius: function(feature) {
+                            return Math.min(feature.attributes.count, 7) + 3;
+                        }
+                    }
+                });
+
+                var photos = new OpenLayers.Layer.Vector("Photos", {
+                    strategies: [
+                        new OpenLayers.Strategy.Fixed(),
+                        new OpenLayers.Strategy.Cluster()
+                    ],
+                    protocol: new OpenLayers.Protocol.HTTP({
+                        url: "http://labs.metacarta.com/flickrbrowse/flickr.py/flickr",
+                        params: {
+                            format: "WFS",
+                            sort: "interestingness-desc",
+                            service: "WFS",
+                            request: "GetFeatures",
+                            srs: "EPSG:4326",
+                            maxfeatures: 150,
+                            bbox: [-180, -90, 180, 90]
+                        },
+                        format: new OpenLayers.Format.GML()
+                    }),
+                    styleMap: new OpenLayers.StyleMap({
+                        "default": style,
+                        "select": {
+                            fillColor: "#8aeeef",
+                            strokeColor: "#32a8a9"
+                        }
+                    })
+                });
+                
+                var select = new OpenLayers.Control.SelectFeature(
+                    photos, {hover: true}
+                );
+                map.addControl(select);
+                select.activate();
+                photos.events.on({"featureselected": display});
+
+                map.addLayers([base, photos]);
+                map.setCenter(new OpenLayers.LonLat(0, 0), 1);
+                
+                // template setup
+                template = new Jugl.Template("template");
+
+            }
+            
+            function display(event) {
+                // clear previous photo list and create new one
+                $("photos").innerHTML = "";
+                var node = template.process({
+                    context: {features: event.feature.cluster},
+                    clone: true,
+                    parent: $("photos")
+                });
+                // set up forward/rewind
+                var forward = Animator.apply($("list"), ["start", "end"], {duration: 1500});
+                $("scroll-end").onmouseover = function() {forward.seekTo(1)};
+                $("scroll-end").onmouseout = function() {forward.seekTo(forward.state)};
+                $("scroll-start").onmouseover = function() {forward.seekTo(0)};
+                $("scroll-start").onmouseout = function() {forward.seekTo(forward.state)};
+                // set up photo zoom
+                for(var i=0; i<event.feature.cluster.length; ++i) {
+                    listen($("link-" + i), Animator.apply($("photo-" + i), ["thumb", "big"]));
+                }
+            }
+            
+            function listen(el, anim) {
+                el.onmouseover = function() {anim.seekTo(1)};
+                el.onmouseout = function() {anim.seekTo(0)};
+            }
+            
+        </script>
+    </head>
+    <body onload="init()">
+        <h1 id="title">Cluster Strategy Example</h1>
+        <p id="shortdesc">
+            Uses a cluster strategy to render points representing clusters of features.
+        </p>
+        <div id="map" class="smallmap"></div>
+        <div id="docs">
+            <p>The Cluster strategy lets you display points representing clusters
+            of features within some pixel distance.</p>
+        </div>
+        <div id="photos"></div>
+        <p>Hover over a cluster on the map to see the photos it includes.</p>
+        <div style="display: none;">
+            <div id="template">
+                <div class="shift" id="scroll-start">&lt;&lt;</div>
+                <div id="scroll">
+                    <ul id="list" class="start">
+                        <li jugl:repeat="feature features">
+                            <a jugl:attributes="href feature.attributes.img_url;
+                                                id 'link-' + repeat.feature.index"
+                               target="_blank">
+                                <img jugl:attributes="src feature.attributes.img_url;
+                                                      title feature.attributes.title;
+                                                      id 'photo-' + repeat.feature.index"
+                                     class="thumb" />
+                            </a>
+                        </li>
+                    </ul>
+                </div>
+                <div class="shift" id="scroll-end">&gt;&gt;</div>
+            </div>
+        </div>
+    </body>
+</html>
diff --git a/examples/strategy-paging.html b/examples/strategy-paging.html
new file mode 100644
index 0000000000..3e0d54f62c
--- /dev/null
+++ b/examples/strategy-paging.html
@@ -0,0 +1,78 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+    <head>
+        <title>OpenLayers Paging Strategy Example</title>
+        <link rel="stylesheet" href="../theme/default/style.css" type="text/css" />
+        <link rel="stylesheet" href="style.css" type="text/css" />
+        <script src="../lib/OpenLayers.js"></script>
+        <script type="text/javascript">
+            var map, photos, paging;
+            OpenLayers.ProxyHost = (window.location.host == "localhost") ?
+                "/cgi-bin/proxy.cgi?url=" : "proxy.cgi?url=";
+        
+            function init() {
+                map = new OpenLayers.Map('map', {
+                    restrictedExtent: new OpenLayers.Bounds(-180, -90, 180, 90)
+                });
+                var base = new OpenLayers.Layer.WMS("OpenLayers WMS", 
+                    ["http://t3.labs.metacarta.com/wms-c/Basic.py",
+                     "http://t2.labs.metacarta.com/wms-c/Basic.py",
+                     "http://t1.labs.metacarta.com/wms-c/Basic.py"], 
+                    {layers: 'satellite'}
+                );
+
+                var style = new OpenLayers.Style({
+                    externalGraphic: "${img_url}",
+                    pointRadius: 30
+                });
+
+                paging = new OpenLayers.Strategy.Paging();
+
+                photos = new OpenLayers.Layer.Vector("Photos", {
+                    strategies: [new OpenLayers.Strategy.Fixed(), paging],
+                    protocol: new OpenLayers.Protocol.HTTP({
+                        url: "http://labs.metacarta.com/flickrbrowse/flickr.py/flickr",
+                        params: {
+                            format: "WFS",
+                            sort: "interestingness-desc",
+                            service: "WFS",
+                            request: "GetFeatures",
+                            srs: "EPSG:4326",
+                            maxfeatures: 100,
+                            bbox: [-180, -90, 180, 90]
+                        },
+                        format: new OpenLayers.Format.GML()
+                    }),
+                    styleMap: new OpenLayers.StyleMap(style)
+                });
+
+                map.addLayers([base, photos]);
+                photos.events.on({"featuresadded": updateButtons});
+                map.setCenter(new OpenLayers.LonLat(0, 0), 1);
+            }
+            
+            function updateButtons() {
+                document.getElementById("prev").disabled = (paging.pageNum() < 1);
+                document.getElementById("next").disabled = (paging.pageNum() >= paging.pageCount() - 1);
+                document.getElementById("num").innerHTML = paging.pageNum() + 1;
+                document.getElementById("count").innerHTML = paging.pageCount();
+            }
+        </script>
+    </head>
+    <body onload="init()">
+        <h1 id="title">Paging Strategy Example</h1>
+        <p id="shortdesc">
+            Uses a paging strategy to cache large batches of features and render a page at a time.
+        </p>
+        <div id="map" class="smallmap"></div>
+        Displaying page <span id="num">0</span> of <span id="count">...</span>
+        <button id="prev" disabled="disabled" onclick="paging.pagePrevious();">previous</button>
+        <button id="next" disabled="disabled" onclick="paging.pageNext();">next</button>
+        <br /><br />
+        <div id="docs">
+            <p>The Paging strategy lets you apply client side paging for protocols
+            that do not support paging on the server.  In this case, the protocol requests a
+            batch of 100 features, the strategy caches those and supplies a single
+            page at a time to the layer.</p>
+        </div>
+    </body>
+</html>
diff --git a/examples/vector-formats.html b/examples/vector-formats.html
index e01406048b..714f12d939 100644
--- a/examples/vector-formats.html
+++ b/examples/vector-formats.html
@@ -52,24 +52,38 @@
             var in_options = {
                 'internalProjection': map.baseLayer.projection,
                 'externalProjection': new OpenLayers.Projection(OpenLayers.Util.getElement("inproj").value)
-            }    
+            };   
             var out_options = {
                 'internalProjection': map.baseLayer.projection,
                 'externalProjection': new OpenLayers.Projection(OpenLayers.Util.getElement("outproj").value)
-            }    
+            };
+            var gmlOptions = {
+                featureType: "feature",
+                featureNS: "http://example.com/feature"
+            };
+            var gmlOptionsIn = OpenLayers.Util.extend(
+                OpenLayers.Util.extend({}, gmlOptions),
+                in_options
+            );
+            var gmlOptionsOut = OpenLayers.Util.extend(
+                OpenLayers.Util.extend({}, gmlOptions),
+                out_options
+            );
             formats = {
               'in': {
                 wkt: new OpenLayers.Format.WKT(in_options),
                 geojson: new OpenLayers.Format.GeoJSON(in_options),
                 georss: new OpenLayers.Format.GeoRSS(in_options),
-                gml: new OpenLayers.Format.GML(in_options),
+                gml2: new OpenLayers.Format.GML.v2(gmlOptionsIn),
+                gml3: new OpenLayers.Format.GML.v3(gmlOptionsIn),
                 kml: new OpenLayers.Format.KML(in_options)
               }, 
               'out': {
                 wkt: new OpenLayers.Format.WKT(out_options),
                 geojson: new OpenLayers.Format.GeoJSON(out_options),
                 georss: new OpenLayers.Format.GeoRSS(out_options),
-                gml: new OpenLayers.Format.GML(out_options),
+                gml2: new OpenLayers.Format.GML.v2(gmlOptionsOut),
+                gml3: new OpenLayers.Format.GML.v3(gmlOptionsOut),
                 kml: new OpenLayers.Format.KML(out_options)
               } 
             };
@@ -169,7 +183,8 @@
                 <option value="geojson" selected="selected">GeoJSON</option>
                 <option value="kml">KML</option>
                 <option value="georss">GeoRSS</option>
-                <option value="gml">GML</option>
+                <option value="gml2">GML (v2)</option>
+                <option value="gml3">GML (v3)</option>
                 <option value="wkt">Well-Known Text (WKT)</option>
             </select>
             &nbsp;
diff --git a/examples/wfs-reprojection.html b/examples/wfs-reprojection.html
index 1076fa430a..ef45be0848 100644
--- a/examples/wfs-reprojection.html
+++ b/examples/wfs-reprojection.html
@@ -45,7 +45,7 @@
             // (only if your wfs doens't support your map projection)
             var wfs = layer = new OpenLayers.Layer.WFS(
                 "States (SVG)",
-                "http://sigma.openplans.org:8080/geoserver/ows",
+                "http://sigma.openplans.org/geoserver/ows",
                 {typename: 'topp:states'},
                 {
                     typename: 'states',
@@ -60,7 +60,7 @@
             
             var wfs = layer = new OpenLayers.Layer.WFS(
                 "States (Canvas)",
-                "http://sigma.openplans.org:8080/geoserver/ows",
+                "http://sigma.openplans.org/geoserver/ows",
                 {typename: 'topp:states'},
                 {
                     typename: 'states',
diff --git a/lib/Gears/gears_init.js b/lib/Gears/gears_init.js
new file mode 100644
index 0000000000..d531a3f5bb
--- /dev/null
+++ b/lib/Gears/gears_init.js
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2007, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. Neither the name of Google Inc. nor the names of its contributors may be
+ *     used to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Sets up google.gears.*, which is *the only* supported way to access Gears.
+ *
+ * Circumvent this file at your own risk!
+ *
+ * In the future, Gears may automatically define google.gears.* without this
+ * file. Gears may use these objects to transparently fix bugs and compatibility
+ * issues. Applications that use the code below will continue to work seamlessly
+ * when that happens.
+ */
+
+(function() {
+  // We are already defined. Hooray!
+  if (window.google && google.gears) {
+    return;
+  }
+
+  var factory = null;
+
+  // Firefox
+  if (typeof GearsFactory != 'undefined') {
+    factory = new GearsFactory();
+  } else {
+    // IE
+    try {
+      factory = new ActiveXObject('Gears.Factory');
+      // privateSetGlobalObject is only required and supported on WinCE.
+      if (factory.getBuildInfo().indexOf('ie_mobile') != -1) {
+        factory.privateSetGlobalObject(this);
+      }
+    } catch (e) {
+      // Safari
+      if ((typeof navigator.mimeTypes != 'undefined')
+           && navigator.mimeTypes["application/x-googlegears"]) {
+        factory = document.createElement("object");
+        factory.style.display = "none";
+        factory.width = 0;
+        factory.height = 0;
+        factory.type = "application/x-googlegears";
+        document.documentElement.appendChild(factory);
+      }
+    }
+  }
+
+  // *Do not* define any objects if Gears is not installed. This mimics the
+  // behavior of Gears defining the objects in the future.
+  if (!factory) {
+    return;
+  }
+
+  // Now set up the objects, being careful not to overwrite anything.
+  //
+  // Note: In Internet Explorer for Windows Mobile, you can't add properties to
+  // the window object. However, global objects are automatically added as
+  // properties of the window object in all browsers.
+  if (!window.google) {
+    google = {};
+  }
+
+  if (!google.gears) {
+    google.gears = {factory: factory};
+  }
+})();
diff --git a/lib/OpenLayers.js b/lib/OpenLayers.js
index 43cdff7f78..4beda022ad 100644
--- a/lib/OpenLayers.js
+++ b/lib/OpenLayers.js
@@ -83,6 +83,7 @@
             "OpenLayers/Tween.js",
             "Rico/Corner.js",
             "Rico/Color.js",
+            "Gears/gears_init.js",
             "OpenLayers/Ajax.js",
             "OpenLayers/Request.js",
             "OpenLayers/Request/XMLHttpRequest.js",
@@ -164,6 +165,7 @@
             "OpenLayers/Control/Panel.js",
             "OpenLayers/Control/SelectFeature.js",
             "OpenLayers/Control/NavigationHistory.js",
+            "OpenLayers/Control/Measure.js",
             "OpenLayers/Geometry.js",
             "OpenLayers/Geometry/Rectangle.js",
             "OpenLayers/Geometry/Collection.js",
@@ -184,8 +186,13 @@
             "OpenLayers/Layer/Vector.js",
             "OpenLayers/Strategy.js",
             "OpenLayers/Strategy/Fixed.js",
+            "OpenLayers/Strategy/Cluster.js",
+            "OpenLayers/Strategy/Paging.js",
+            "OpenLayers/Strategy/BBOX.js",
             "OpenLayers/Protocol.js",
             "OpenLayers/Protocol/HTTP.js",
+            "OpenLayers/Protocol/SQL.js",
+            "OpenLayers/Protocol/SQL/Gears.js",
             "OpenLayers/Layer/PointTrack.js",
             "OpenLayers/Layer/GML.js",
             "OpenLayers/Style.js",
@@ -199,6 +206,9 @@
             "OpenLayers/Format.js",
             "OpenLayers/Format/XML.js",
             "OpenLayers/Format/GML.js",
+            "OpenLayers/Format/GML/Base.js",
+            "OpenLayers/Format/GML/v2.js",
+            "OpenLayers/Format/GML/v3.js",
             "OpenLayers/Format/KML.js",
             "OpenLayers/Format/GeoRSS.js",
             "OpenLayers/Format/WFS.js",
diff --git a/lib/OpenLayers/Control/Permalink.js b/lib/OpenLayers/Control/Permalink.js
index 6eb0849ddb..34013a7023 100644
--- a/lib/OpenLayers/Control/Permalink.js
+++ b/lib/OpenLayers/Control/Permalink.js
@@ -168,8 +168,6 @@ OpenLayers.Control.Permalink = OpenLayers.Class(OpenLayers.Control, {
      */
     createParams: function(center, zoom, layers) {
         center = center || this.map.getCenter();
-        zoom = zoom || this.map.getZoom();
-        layers = layers || this.map.layers;  
           
         var params = OpenLayers.Util.getParameters(this.base);
         
@@ -177,8 +175,11 @@ OpenLayers.Control.Permalink = OpenLayers.Class(OpenLayers.Control, {
         // Break out of this function, and simply return the params from the
         // base link.
         if (center) { 
-    
-            params.zoom = this.map.getZoom(); 
+
+            //zoom
+            params.zoom = zoom || this.map.getZoom(); 
+
+            //lon,lat
             var lat = center.lat;
             var lon = center.lon;
             
@@ -192,10 +193,12 @@ OpenLayers.Control.Permalink = OpenLayers.Class(OpenLayers.Control, {
             }       
             params.lat = Math.round(lat*100000)/100000;
             params.lon = Math.round(lon*100000)/100000;
-            
+    
+            //layers        
+            layers = layers || this.map.layers;  
             params.layers = '';
-            for (var i=0, len=this.map.layers.length; i<len; i++) {
-                var layer = this.map.layers[i];
+            for (var i=0, len=layers.length; i<len; i++) {
+                var layer = layers[i];
     
                 if (layer.isBaseLayer) {
                     params.layers += (layer == this.map.baseLayer) ? "B" : "0";
diff --git a/lib/OpenLayers/Format.js b/lib/OpenLayers/Format.js
index c809c46f92..0faf7170ec 100644
--- a/lib/OpenLayers/Format.js
+++ b/lib/OpenLayers/Format.js
@@ -13,6 +13,12 @@
  */
 OpenLayers.Format = OpenLayers.Class({
     
+    /**
+     * Property: options
+     * {Object} A reference to options passed to the constructor.
+     */
+    options: null,
+    
     /**
      * APIProperty: externalProjection
      * {<OpenLayers.Projection>} When passed a externalProjection and
@@ -54,6 +60,14 @@ OpenLayers.Format = OpenLayers.Class({
      */
     initialize: function(options) {
         OpenLayers.Util.extend(this, options);
+        this.options = options;
+    },
+    
+    /**
+     * APIMethod: destroy
+     * Clean up.
+     */
+    destroy: function() {
     },
 
     /**
diff --git a/lib/OpenLayers/Format/GML/Base.js b/lib/OpenLayers/Format/GML/Base.js
new file mode 100644
index 0000000000..7562db737c
--- /dev/null
+++ b/lib/OpenLayers/Format/GML/Base.js
@@ -0,0 +1,525 @@
+/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
+ * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the
+ * full text of the license. */
+
+/**
+ * @requires OpenLayers/Format/XML.js
+ */
+
+/**
+ * Eventually, this will require the OpenLayers.Format.GML.  For now, since
+ *     this parser can be included in a lib without the old GML parser, we
+ *     declare the namespace if it doesn't exist.
+ */
+if(!OpenLayers.Format.GML) {
+    OpenLayers.Format.GML = {};
+}
+
+/**
+ * Class: OpenLayers.Format.GML.Base
+ * Superclass for GML parsers.
+ *
+ * Inherits from:
+ *  - <OpenLayers.Format.XML>
+ */
+OpenLayers.Format.GML.Base = OpenLayers.Class(OpenLayers.Format.XML, {
+    
+    /**
+     * Property: namespaces
+     * {Object} Mapping of namespace aliases to namespace URIs.
+     */
+    namespaces: {
+        gml: "http://www.opengis.net/gml",
+        xlink: "http://www.w3.org/1999/xlink",
+        xsi: "http://www.w3.org/2001/XMLSchema-instance",
+        wfs: "http://www.opengis.net/wfs" // this is a convenience for reading wfs:FeatureCollection
+    },
+    
+    /**
+     * Property: defaultPrefix
+     */
+    defaultPrefix: "gml",
+
+    /**
+     * Property: schemaLocation
+     * {String} Schema location for a particular minor version.
+     */
+    schemaLocation: null,
+    
+    /**
+     * APIProperty: featureType
+     * {String} The local (without prefix) feature typeName.
+     */
+    featureType: null,
+    
+    /**
+     * APIProperty: featureNS
+     * {String} The feature namespace.  Must be set in the options at
+     *     construction.
+     */
+    featureNS: null,
+
+    /**
+     * APIProperty: geometry
+     * {String} Name of geometry element.  Defaults to "geometry".
+     */
+    geometryName: "geometry",
+
+    /**
+     * APIProperty: extractAttributes
+     * {Boolean} Extract attributes from GML.  Default is true.
+     */
+    extractAttributes: true,
+    
+    /**
+     * APIProperty: srsName
+     * {String} URI for spatial reference system.  This is optional for
+     *     single part geometries and mandatory for collections and multis.
+     *     If set, the srsName attribute will be written for all geometries.
+     *     Default is null.
+     */
+    srsName: null,
+
+    /**
+     * APIProperty: xy
+     * {Boolean} Order of the GML coordinate true:(x,y) or false:(y,x)
+     * Changing is not recommended, a new Format should be instantiated.
+     */ 
+    xy: true,
+
+    /**
+     * Property: regExes
+     * Compiled regular expressions for manipulating strings.
+     */
+    regExes: {
+        trimSpace: (/^\s*|\s*$/g),
+        removeSpace: (/\s*/g),
+        splitSpace: (/\s+/),
+        trimComma: (/\s*,\s*/g)
+    },
+
+    /**
+     * Constructor: OpenLayers.Format.GML.Base
+     * Instances of this class are not created directly.  Use the
+     *     <OpenLayers.Format.GML.v2> or <OpenLayers.Format.GML.v3> constructor
+     *     instead.
+     *
+     * Parameters:
+     * options - {Object} An optional object whose properties will be set on
+     *     this instance.
+     *
+     * Valid options properties:
+     * featureType - {String} Local (without prefix) feature typeName (required).
+     * featureNS - {String} Feature namespace (required).
+     * geometryName - {String} Geometry element name.
+     */
+    initialize: function(options) {
+        OpenLayers.Format.XML.prototype.initialize.apply(this, [options]);
+        this.setNamespace("feature", options.featureNS);
+    },
+    
+    /**
+     * Method: read
+     *
+     * Parameters:
+     * data - {DOMElement} A gml:featureMember element, a gml:featureMembers
+     *     element, or an element containing either of the above at any level.
+     *
+     * Returns:
+     * {Array(<OpenLayers.Feature.Vector>)} An array of features.
+     */
+    read: function(data) {
+        if(typeof data == "string") { 
+            data = OpenLayers.Format.XML.prototype.read.apply(this, [data]);
+        }
+        if(data && data.nodeType == 9) {
+            data = data.documentElement;
+        }
+        var features = [];
+        this.readNode(data, {features: features});
+        if(features.length == 0) {
+            // look for gml:featureMember elements
+            var elements = this.getElementsByTagNameNS(
+                data, this.namespaces.gml, "featureMember"
+            );
+            if(elements.length) {
+                for(var i=0, len=elements.length; i<len; ++i) {
+                    this.readNode(elements[i], {features: features});
+                }
+            } else {
+                // look for gml:featureMembers elements (this is v3, but does no harm here)
+                var elements = this.getElementsByTagNameNS(
+                    data, this.namespaces.gml, "featureMembers"
+                );
+                if(elements.length) {
+                    // there can be only one
+                    this.readNode(elements[0], {features: features});
+                }
+            }
+        }
+        return features;
+    },
+    
+    /**
+     * Property: readers
+     * Contains public functions, grouped by namespace prefix, that will
+     *     be applied when a namespaced node is found matching the function
+     *     name.  The function will be applied in the scope of this parser
+     *     with two arguments: the node being read and a context object passed
+     *     from the parent.
+     */
+    readers: {
+        "gml": {
+            "featureMember": function(node, obj) {
+                this.readChildNodes(node, obj);
+            },
+            "featureMembers": function(node, obj) {
+                this.readChildNodes(node, obj);                
+            },
+            "Point": function(node, container) {
+                var obj = {points: []};
+                this.readChildNodes(node, obj);
+                if(!container.components) {
+                    container.components = [];
+                }
+                container.components.push(obj.points[0]);
+            },
+            "coordinates": function(node, obj) {
+                var str = this.concatChildValues(node).replace(
+                    this.regExes.trimSpace, ""
+                );
+                str = str.replace(this.regExes.trimComma, ",");
+                var pointList = str.split(this.regExes.splitSpace);
+                var coords;
+                var numPoints = pointList.length;
+                var points = new Array(numPoints);
+                for(var i=0; i<numPoints; ++i) {
+                    coords = pointList[i].split(",");
+                    if (this.xy) {
+                        points[i] = new OpenLayers.Geometry.Point(
+                            coords[0], coords[1], coords[2]
+                        );
+                    } else {
+                        points[i] = new OpenLayers.Geometry.Point(
+                            coords[1], coords[0], coords[2]
+                        );
+                    }
+                }
+                obj.points = points;
+            },
+            "coord": function(node, obj) {
+                var coord = {};
+                this.readChildNodes(node, coord);
+                if(!obj.points) {
+                    obj.points = [];
+                }
+                obj.points.push(new OpenLayers.Geometry.Point(
+                    coord.x, coord.y, coord.z
+                ));
+            },
+            "X": function(node, coord) {
+                coord.x = this.getChildValue(node);
+            },
+            "Y": function(node, coord) {
+                coord.y = this.getChildValue(node);
+            },
+            "Z": function(node, coord) {
+                coord.z = this.getChildValue(node);
+            },
+            "MultiPoint": function(node, container) {
+                var obj = {components: []};
+                this.readChildNodes(node, obj);
+                container.components = [
+                    new OpenLayers.Geometry.MultiPoint(obj.components)
+                ];
+            },
+            "pointMember": function(node, obj) {
+                this.readChildNodes(node, obj);
+            },
+            "LineString": function(node, container) {
+                var obj = {};
+                this.readChildNodes(node, obj);
+                if(!container.components) {
+                    container.components = [];
+                }
+                container.components.push(
+                    new OpenLayers.Geometry.LineString(obj.points)
+                );
+            },
+            "MultiLineString": function(node, container) {
+                var obj = {components: []};
+                this.readChildNodes(node, obj);
+                container.components = [
+                    new OpenLayers.Geometry.MultiLineString(obj.components)
+                ];
+            },
+            "lineStringMember": function(node, obj) {
+                this.readChildNodes(node, obj);
+            },
+            "Polygon": function(node, container) {
+                var obj = {outer: null, inner: []};
+                this.readChildNodes(node, obj);
+                obj.inner.unshift(obj.outer);
+                if(!container.components) {
+                    container.components = [];
+                }
+                container.components.push(
+                    new OpenLayers.Geometry.Polygon(obj.inner)
+                );
+            },
+            "LinearRing": function(node, obj) {
+                var container = {};
+                this.readChildNodes(node, container);
+                obj.components = [new OpenLayers.Geometry.LinearRing(
+                    container.points
+                )];
+            },
+            "MultiPolygon": function(node, container) {
+                var obj = {components: []};
+                this.readChildNodes(node, obj);
+                container.components = [
+                    new OpenLayers.Geometry.MultiPolygon(obj.components)
+                ];
+            },
+            "polygonMember": function(node, obj) {
+                this.readChildNodes(node, obj);
+            },
+            "GeometryCollection": function(node, container) {
+                var obj = {components: []};
+                this.readChildNodes(node, obj);
+                container.components = [
+                    new OpenLayers.Geometry.Collection(obj.components)
+                ];
+            },
+            "geometryMember": function(node, obj) {
+                this.readChildNodes(node, obj);
+            }
+        },
+        "feature": {
+            "*": function(node, obj) {
+                // The node can either be named like the featureType, or it
+                // can be a child of the feature:featureType.  Children can be
+                // geometry or attributes.
+                var name;
+                var local = node.localName || node.nodeName.split(":").pop();
+                if(local == this.featureType) {
+                    name = "_typeName";
+                } else {
+                    // Assume attribute elements have one child node and that the child
+                    // is a text node.  Otherwise assume it is a geometry node.
+                    if(node.childNodes.length == 1 && node.firstChild.nodeType == 3) {
+                        if(this.extractAttributes) {
+                            name = "_attribute";
+                        }
+                    } else {
+                        name = "_geometry";
+                    }
+                }
+                if(name) {
+                    this.readers.feature[name].apply(this, [node, obj]);
+                }
+            },
+            "_typeName": function(node, obj) {
+                var container = {components: [], attributes: {}};
+                this.readChildNodes(node, container);
+                var feature = new OpenLayers.Feature.Vector(
+                    container.components[0], container.attributes
+                );
+                var fid = node.getAttribute("fid") ||
+                    this.getAttributeNS(node, this.namespaces["gml"], "id");
+                if(fid) {
+                    feature.fid = fid;
+                }
+                if(this.internalProjection && this.externalProjection &&
+                   feature.geometry) {
+                    feature.geometry.transform(
+                        this.externalProjection, this.internalProjection
+                    );
+                }                       
+                obj.features.push(feature);
+            },
+            "_geometry": function(node, obj) {
+                this.readChildNodes(node, obj);
+            },
+            "_attribute": function(node, obj) {
+                var local = node.localName || node.nodeName.split(":").pop();
+                var value = this.getChildValue(node);
+                obj.attributes[local] = value;
+            }
+        },
+        "wfs": {
+            "FeatureCollection": function(node, obj) {
+                this.readChildNodes(node, obj);
+            }
+        }
+    },
+    
+    /**
+     * Method: write
+     *
+     * Parameters:
+     * features - {Array(<OpenLayers.Feature.Vector>) | OpenLayers.Feature.Vector}
+     *     An array of features or a single feature.
+     *
+     * Returns:
+     * {String} Given an array of features, a doc with a gml:featureMembers
+     *     element will be returned.  Given a single feature, a doc with a
+     *     gml:featureMember element will be returned.
+     */
+    write: function(features) {
+        var name;
+        if(features instanceof Array) {
+            name = "featureMembers";
+        } else {
+            name = "featureMember";
+        }
+        var root = this.writeNode("gml:" + name, features);
+        this.setAttributeNS(
+            root, this.namespaces["xsi"],
+            "xsi:schemaLocation", this.schemaLocation
+        );
+
+        return OpenLayers.Format.XML.prototype.write.apply(this, [root]);
+    },
+    
+    /**
+     * Property: writers
+     * As a compliment to the readers property, this structure contains public
+     *     writing functions grouped by namespace alias and named like the
+     *     node names they produce.
+     */
+    writers: {
+        "gml": {
+            "featureMember": function(feature) {
+                var node = this.createElementNSPlus("gml:featureMember");
+                this.writeNode("feature:_typeName", feature, node);
+                return node;
+            },
+            "MultiPoint": function(geometry) {
+                var node = this.createElementNSPlus("gml:MultiPoint");
+                for(var i=0; i<geometry.components.length; ++i) {
+                    this.writeNode("pointMember", geometry.components[i], node);
+                }
+                return node;
+            },
+            "pointMember": function(geometry) {
+                var node = this.createElementNSPlus("gml:pointMember");
+                this.writeNode("Point", geometry, node);
+                return node;
+            },
+            "MultiLineString": function(geometry) {
+                var node = this.createElementNSPlus("gml:MultiLineString");
+                for(var i=0; i<geometry.components.length; ++i) {
+                    this.writeNode("lineStringMember", geometry.components[i], node);
+                }
+                return node;
+            },
+            "lineStringMember": function(geometry) {
+                var node = this.createElementNSPlus("gml:lineStringMember");
+                this.writeNode("LineString", geometry, node);
+                return node;
+            },
+            "MultiPolygon": function(geometry) {
+                var node = this.createElementNSPlus("gml:MultiPolygon");
+                for(var i=0; i<geometry.components.length; ++i) {
+                    this.writeNode(
+                        "polygonMember", geometry.components[i], node
+                    );
+                }
+                return node;
+            },
+            "polygonMember": function(geometry) {
+                var node = this.createElementNSPlus("gml:polygonMember");
+                this.writeNode("Polygon", geometry, node);
+                return node;
+            },
+            "GeometryCollection": function(geometry) {
+                var node = this.createElementNSPlus("gml:GeometryCollection");
+                for(var i=0, len=geometry.components.length; i<len; ++i) {
+                    this.writeNode("geometryMember", geometry.components[i], node);
+                }
+                return node;
+            },
+            "geometryMember": function(geometry) {
+                var node = this.createElementNSPlus("gml:geometryMember");
+                var child = this.writeNode("feature:_geometry", geometry);
+                node.appendChild(child.firstChild);
+                return node;
+            }
+        },
+        "feature": {
+            "_typeName": function(feature) {
+                var node = this.createElementNSPlus("feature:" + this.featureType, {
+                    attributes: {fid: feature.fid}
+                });
+                if(feature.geometry) {
+                    this.writeNode("feature:_geometry", feature.geometry, node);
+                }
+                for(var name in feature.attributes) {
+                    var value = feature.attributes[name];
+                    if(value != null) {
+                        this.writeNode(
+                            "feature:_attribute",
+                            {name: name, value: value}, node
+                        )
+                    }
+                }
+                return node;
+            },
+            "_geometry": function(geometry) {
+                if(this.externalProjection && this.internalProjection) {
+                    geometry = geometry.clone().transform(
+                        this.internalProjection, this.externalProjection
+                    );
+                }    
+                var node = this.createElementNSPlus(
+                    "feature:" + this.geometryName
+                );
+                var type = this.geometryTypes[geometry.CLASS_NAME];
+                var child = this.writeNode("gml:" + type, geometry, node);
+                if(this.srsName) {
+                    child.setAttribute("srsName", this.srsName);
+                }
+                return node;
+            },
+            "_attribute": function(obj) {
+                return this.createElementNSPlus("feature:" + obj.name, {
+                    value: obj.value
+                });
+            }
+        },
+        "wfs": {
+            "FeatureCollection": function(features) {
+                /**
+                 * This is only here because GML2 only describes abstract
+                 * feature collections.  Typically, you would not be using
+                 * the GML format to write wfs elements.  This just provides
+                 * some way to write out lists of features.  GML3 defines the
+                 * featureMembers element, so that is used by default instead.
+                 */
+                var node = this.createElementNSPlus("wfs:FeatureCollection");
+                for(var i=0, len=features.length; i<len; ++i) {
+                    this.writeNode("gml:featureMember", features[i], node);
+                }
+                return node;
+            }
+        }
+    },
+    
+    /**
+     * Property: geometryTypes
+     * {Object} Maps OpenLayers geometry class names to GML element names.
+     */
+    geometryTypes: {
+        "OpenLayers.Geometry.Point": "Point",
+        "OpenLayers.Geometry.MultiPoint": "MultiPoint",
+        "OpenLayers.Geometry.LineString": "LineString",
+        "OpenLayers.Geometry.MultiLineString": "MultiLineString",
+        "OpenLayers.Geometry.Polygon": "Polygon",
+        "OpenLayers.Geometry.MultiPolygon": "MultiPolygon",
+        "OpenLayers.Geometry.Collection": "GeometryCollection"
+    },
+
+    CLASS_NAME: "OpenLayers.Format.GML.Base" 
+
+});
diff --git a/lib/OpenLayers/Format/GML/v2.js b/lib/OpenLayers/Format/GML/v2.js
new file mode 100644
index 0000000000..7bbf65f709
--- /dev/null
+++ b/lib/OpenLayers/Format/GML/v2.js
@@ -0,0 +1,192 @@
+/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
+ * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the
+ * full text of the license. */
+
+/**
+ * @requires OpenLayers/Format/GML/Base.js
+ */
+
+/**
+ * Class: OpenLayers.Format.GML.v2
+ * Parses GML version 2.
+ *
+ * Inherits from:
+ *  - <OpenLayers.Format.GML.Base>
+ */
+OpenLayers.Format.GML.v2 = OpenLayers.Class(OpenLayers.Format.GML.Base, {
+    
+    /**
+     * Property: schemaLocation
+     * {String} Schema location for a particular minor version.
+     */
+    schemaLocation: "http://www.opengis.net/gml http://schemas.opengis.net/gml/2.1.2/feature.xsd",
+
+    /**
+     * Constructor: OpenLayers.Format.GML.v2
+     * Create a parser for GML v2.
+     *
+     * Parameters:
+     * options - {Object} An optional object whose properties will be set on
+     *     this instance.
+     *
+     * Valid options properties:
+     * featureType - {String} Local (without prefix) feature typeName (required).
+     * featureNS - {String} Feature namespace (required).
+     * geometryName - {String} Geometry element name.
+     */
+    initialize: function(options) {
+        OpenLayers.Format.GML.Base.prototype.initialize.apply(this, [options]);
+    },
+
+    /**
+     * Property: readers
+     * Contains public functions, grouped by namespace prefix, that will
+     *     be applied when a namespaced node is found matching the function
+     *     name.  The function will be applied in the scope of this parser
+     *     with two arguments: the node being read and a context object passed
+     *     from the parent.
+     */
+    readers: {
+        "gml": OpenLayers.Util.applyDefaults({
+            "outerBoundaryIs": function(node, container) {
+                var obj = {};
+                this.readChildNodes(node, obj);
+                container.outer = obj.components[0];
+            },
+            "innerBoundaryIs": function(node, container) {
+                var obj = {};
+                this.readChildNodes(node, obj);
+                container.inner.push(obj.components[0]);
+            },
+            "Box": function(node, container) {
+                var obj = {};
+                this.readChildNodes(node, obj);
+                if(!container.components) {
+                    container.components = [];
+                }
+                var min = obj.points[0];
+                var max = obj.points[1];
+                container.components.push(
+                    new OpenLayers.Bounds(min.x, min.y, max.x, max.y)
+                );
+            }
+        }, OpenLayers.Format.GML.Base.prototype.readers["gml"]),
+        "feature": OpenLayers.Format.GML.Base.prototype.readers["feature"],
+        "wfs": OpenLayers.Format.GML.Base.prototype.readers["wfs"]
+    },
+
+    /**
+     * Method: write
+     *
+     * Parameters:
+     * features - {Array(<OpenLayers.Feature.Vector>) | OpenLayers.Feature.Vector}
+     *     An array of features or a single feature.
+     *
+     * Returns:
+     * {String} Given an array of features, a doc with a gml:featureMembers
+     *     element will be returned.  Given a single feature, a doc with a
+     *     gml:featureMember element will be returned.
+     */
+    write: function(features) {
+        var name;
+        if(features instanceof Array) {
+            // GML2 only has abstract feature collections
+            // wfs provides a feature collection from a well-known schema
+            name = "wfs:FeatureCollection";
+        } else {
+            name = "gml:featureMember";
+        }
+        var root = this.writeNode(name, features);
+        this.setAttributeNS(
+            root, this.namespaces["xsi"],
+            "xsi:schemaLocation", this.schemaLocation
+        );
+
+        return OpenLayers.Format.XML.prototype.write.apply(this, [root]);
+    },
+
+    /**
+     * Property: writers
+     * As a compliment to the readers property, this structure contains public
+     *     writing functions grouped by namespace alias and named like the
+     *     node names they produce.
+     */
+    writers: {
+        "gml": OpenLayers.Util.applyDefaults({
+            "Point": function(geometry) {
+                var node = this.createElementNSPlus("gml:Point");
+                this.writeNode("coordinates", [geometry], node);
+                return node;
+            },
+            "coordinates": function(points) {
+                var numPoints = points.length;
+                var parts = new Array(numPoints);
+                var point;
+                for(var i=0; i<numPoints; ++i) {
+                    point = points[i];
+                    if(this.xy) {
+                        parts[i] = point.x + "," + point.y;
+                    } else {
+                        parts[i] = point.y + "," + point.x;
+                    }
+                    if(point.z != undefined) { // allow null or undefined
+                        parts[i] += "," + point.z;
+                    }
+                }
+                return this.createElementNSPlus("gml:coordinates", {
+                    attributes: {
+                        decimal: ".", cs: ",", ts: " "
+                    },
+                    value: (numPoints == 1) ? parts[0] : parts.join(" ")
+                });
+            },
+            "LineString": function(geometry) {
+                var node = this.createElementNSPlus("gml:LineString");
+                this.writeNode("coordinates", geometry.components, node);
+                return node;
+            },
+            "Polygon": function(geometry) {
+                var node = this.createElementNSPlus("gml:Polygon");
+                this.writeNode("outerBoundaryIs", geometry.components[0], node);
+                for(var i=1; i<geometry.components.length; ++i) {
+                    this.writeNode(
+                        "innerBoundaryIs", geometry.components[i], node
+                    );
+                }
+                return node;
+            },
+            "outerBoundaryIs": function(ring) {
+                var node = this.createElementNSPlus("gml:outerBoundaryIs");
+                this.writeNode("LinearRing", ring, node);
+                return node;
+            },
+            "innerBoundaryIs": function(ring) {
+                var node = this.createElementNSPlus("gml:innerBoundaryIs");
+                this.writeNode("LinearRing", ring, node);
+                return node;
+            },
+            "LinearRing": function(ring) {
+                var node = this.createElementNSPlus("gml:LinearRing");
+                this.writeNode("coordinates", ring.components, node);
+                return node;
+            },
+            "Box": function(bounds) {
+                var node = this.createElementNSPlus("gml:Box");
+                this.writeNode("coordinates", [
+                    {x: bounds.left, y: bounds.bottom},
+                    {x: bounds.right, y: bounds.top}
+                ], node);
+                // srsName attribute is optional for gml:Box
+                if(this.srsName) {
+                    node.setAttribute("srsName", this.srsName);
+                }
+                return node;
+            }
+        }, OpenLayers.Format.GML.Base.prototype.writers["gml"]),
+        "feature": OpenLayers.Format.GML.Base.prototype.writers["feature"],
+        "wfs": OpenLayers.Format.GML.Base.prototype.writers["wfs"]
+    },
+    
+    CLASS_NAME: "OpenLayers.Format.GML.v2" 
+
+});
diff --git a/lib/OpenLayers/Format/GML/v3.js b/lib/OpenLayers/Format/GML/v3.js
new file mode 100644
index 0000000000..f07010034b
--- /dev/null
+++ b/lib/OpenLayers/Format/GML/v3.js
@@ -0,0 +1,287 @@
+/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
+ * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the
+ * full text of the license. */
+
+/**
+ * @requires OpenLayers/Format/GML/Base.js
+ */
+
+/**
+ * Class: OpenLayers.Format.GML.v3
+ * Parses GML version 3.
+ *
+ * Inherits from:
+ *  - <OpenLayers.Format.GML.Base>
+ */
+OpenLayers.Format.GML.v3 = OpenLayers.Class(OpenLayers.Format.GML.Base, {
+    
+    /**
+     * Property: schemaLocation
+     * {String} Schema location for a particular minor version.  The writers
+     *     conform with the Simple Features Profile for GML.
+     */
+    schemaLocation: "http://www.opengis.net/gml http://schemas.opengis.net/gml/3.1.1/profiles/gmlsfProfile/1.0.0/gmlsf.xsd",
+
+    /**
+     * Constructor: OpenLayers.Format.GML.v3
+     * Create a parser for GML v3.
+     *
+     * Parameters:
+     * options - {Object} An optional object whose properties will be set on
+     *     this instance.
+     *
+     * Valid options properties:
+     * featureType - {String} Local (without prefix) feature typeName (required).
+     * featureNS - {String} Feature namespace (required).
+     * geometryName - {String} Geometry element name.
+     */
+    initialize: function(options) {
+        OpenLayers.Format.GML.Base.prototype.initialize.apply(this, [options]);
+    },
+
+    /**
+     * Property: readers
+     * Contains public functions, grouped by namespace prefix, that will
+     *     be applied when a namespaced node is found matching the function
+     *     name.  The function will be applied in the scope of this parser
+     *     with two arguments: the node being read and a context object passed
+     *     from the parent.
+     */
+    readers: {
+        "gml": OpenLayers.Util.applyDefaults({
+            "featureMembers": function(node, obj) {
+                this.readChildNodes(node, obj);
+            },
+            "pos": function(node, obj) {
+                var str = this.getChildValue(node).replace(
+                    this.regExes.trimSpace, ""
+                );
+                var coords = str.split(this.regExes.splitSpace);
+                var point;
+                if(this.xy) {
+                    point = new OpenLayers.Geometry.Point(
+                        coords[0], coords[1], coords[2]
+                    );
+                } else {
+                    point = new OpenLayers.Geometry.Point(
+                        coords[1], coords[0], coords[2]
+                    );
+                }
+                obj.points = [point];
+            },
+            "posList": function(node, obj) {
+                var str = this.concatChildValues(node).replace(
+                    this.regExes.trimSpace, ""
+                );
+                var coords = str.split(this.regExes.splitSpace);
+                var dim = parseInt(node.getAttribute("dimension")) || 2;
+                var j, x, y, z;
+                var numPoints = coords.length / dim;
+                var points = new Array(numPoints);
+                for(var i=0, len=coords.length; i<len; i += dim) {
+                    x = coords[i];
+                    y = coords[i+1];
+                    z = (dim == 2) ? undefined : coords[i+2];
+                    if (this.xy) {
+                        points[i/dim] = new OpenLayers.Geometry.Point(x, y, z);
+                    } else {
+                        points[i/dim] = new OpenLayers.Geometry.Point(y, x, z);
+                    }
+                }
+                obj.points = points;
+            },
+            "exterior": function(node, container) {
+                var obj = {};
+                this.readChildNodes(node, obj);
+                container.outer = obj.components[0];
+            },
+            "interior": function(node, container) {
+                var obj = {};
+                this.readChildNodes(node, obj);
+                container.inner.push(obj.components[0]);
+            },
+            "MultiSurface": function(node, container) {
+                var obj = {components: []};
+                this.readChildNodes(node, obj);
+                if(obj.components.length > 0) {
+                    container.components = [
+                        new OpenLayers.Geometry.MultiPolygon(obj.components)
+                    ];
+                }
+            },
+            "surfaceMember": function(node, obj) {
+                this.readChildNodes(node, obj);
+            },
+            "surfaceMembers": function(node, obj) {
+                this.readChildNodes(node, obj);
+            },
+            "pointMembers": function(node, obj) {
+                this.readChildNodes(node, obj);
+            },
+            "lineStringMembers": function(node, obj) {
+                this.readChildNodes(node, obj);
+            },
+            "polygonMembers": function(node, obj) {
+                this.readChildNodes(node, obj);
+            },
+            "geometryMembers": function(node, obj) {
+                this.readChildNodes(node, obj);
+            },
+            "Envelope": function(node, container) {
+                var obj = {points: new Array(2)};
+                this.readChildNodes(node, obj);
+                if(!container.components) {
+                    container.components = [];
+                }
+                var min = obj.points[0];
+                var max = obj.points[1];
+                container.components.push(
+                    new OpenLayers.Bounds(min.x, min.y, max.x, max.y)
+                );
+            },
+            "lowerCorner": function(node, container) {
+                var obj = {};
+                this.readChildNodes(node, obj)
+                container.points[0] = obj.points[0];
+            },
+            "upperCorner": function(node, container) {
+                var obj = {};
+                this.readChildNodes(node, obj)
+                container.points[1] = obj.points[0];
+            }
+        }, OpenLayers.Format.GML.Base.prototype.readers["gml"]),            
+        "feature": OpenLayers.Format.GML.Base.prototype.readers["feature"],
+        "wfs": OpenLayers.Format.GML.Base.prototype.readers["wfs"]
+    },
+    
+    /**
+     * Method: write
+     *
+     * Parameters:
+     * features - {Array(<OpenLayers.Feature.Vector>) | OpenLayers.Feature.Vector}
+     *     An array of features or a single feature.
+     *
+     * Returns:
+     * {String} Given an array of features, a doc with a gml:featureMembers
+     *     element will be returned.  Given a single feature, a doc with a
+     *     gml:featureMember element will be returned.
+     */
+    write: function(features) {
+        var name;
+        if(features instanceof Array) {
+            name = "featureMembers";
+        } else {
+            name = "featureMember";
+        }
+        var root = this.writeNode("gml:" + name, features);
+        this.setAttributeNS(
+            root, this.namespaces["xsi"],
+            "xsi:schemaLocation", this.schemaLocation
+        );
+
+        return OpenLayers.Format.XML.prototype.write.apply(this, [root]);
+    },
+
+    /**
+     * Property: writers
+     * As a compliment to the readers property, this structure contains public
+     *     writing functions grouped by namespace alias and named like the
+     *     node names they produce.
+     */
+    writers: {
+        "gml": OpenLayers.Util.applyDefaults({
+            "featureMembers": function(features) {
+                var node = this.createElementNSPlus("gml:featureMembers");
+                for(var i=0, len=features.length; i<len; ++i) {
+                    this.writeNode("feature:_typeName", features[i], node);
+                }
+                return node;
+            },
+            "Point": function(geometry) {
+                var node = this.createElementNSPlus("gml:Point");
+                this.writeNode("pos", geometry, node);
+                return node;
+            },
+            "pos": function(point) {
+                // only 2d for simple features profile
+                var pos = (this.xy) ?
+                    (point.x + " " + point.y) : (point.y + " " + point.x);
+                return this.createElementNSPlus("gml:pos", {
+                    value: pos
+                });
+            },
+            "LineString": function(geometry) {
+                var node = this.createElementNSPlus("gml:LineString");
+                this.writeNode("posList", geometry.components, node);
+                return node;
+            },
+            "posList": function(points) {
+                // only 2d for simple features profile
+                var len = points.length;
+                var parts = new Array(len);
+                var point;
+                for(var i=0; i<len; ++i) {
+                    point = points[i];
+                    if(this.xy) {
+                        parts[i] = point.x + " " + point.y;
+                    } else {
+                        parts[i] = point.y + " " + point.x;
+                    }
+                }
+                return this.createElementNSPlus("gml:posList", {
+                    value: parts.join(" ")
+                }); 
+            },
+            "Polygon": function(geometry) {
+                var node = this.createElementNSPlus("gml:Polygon");
+                this.writeNode("exterior", geometry.components[0], node);
+                for(var i=1, len=geometry.components.length; i<len; ++i) {
+                    this.writeNode(
+                        "interior", geometry.components[i], node
+                    );
+                }
+                return node;
+            },
+            "exterior": function(ring) {
+                var node = this.createElementNSPlus("gml:exterior");
+                this.writeNode("LinearRing", ring, node);
+                return node;
+            },
+            "interior": function(ring) {
+                var node = this.createElementNSPlus("gml:interior");
+                this.writeNode("LinearRing", ring, node);
+                return node;
+            },
+            "LinearRing": function(ring) {
+                var node = this.createElementNSPlus("gml:LinearRing");
+                this.writeNode("posList", ring.components, node);
+                return node;
+            },
+            "Envelope": function(bounds) {
+                var node = this.createElementNSPlus("gml:Envelope");
+                this.writeNode("lowerCorner", bounds, node);
+                this.writeNode("upperCorner", bounds, node);
+                // srsName attribute is required for gml:Envelope
+                if(this.srsName) {
+                    node.setAttribute("srsName", this.srsName);
+                }
+                return node;
+            },
+            "lowerCorner": function(bounds) {
+                var node = this.createElementNSPlus("gml:lowerCorner");
+                this.writeNode("pos", {x: bounds.left, y: bounds.bottom}, node);
+                return node;
+            },
+            "upperCorner": function(bounds) {
+                var node = this.createElementNSPlus("gml:upperCorner");
+                this.writeNode("pos", {x: bounds.right, y: bounds.top}, node);
+                return node;
+            }
+        }, OpenLayers.Format.GML.Base.prototype.writers["gml"]),
+        "feature": OpenLayers.Format.GML.Base.prototype.writers["feature"],
+        "wfs": OpenLayers.Format.GML.Base.prototype.writers["wfs"]
+    },
+    
+    CLASS_NAME: "OpenLayers.Format.GML.v3" 
+
+});
diff --git a/lib/OpenLayers/Format/XML.js b/lib/OpenLayers/Format/XML.js
index a55f120ff6..e5c57ee267 100644
--- a/lib/OpenLayers/Format/XML.js
+++ b/lib/OpenLayers/Format/XML.js
@@ -19,6 +19,46 @@
  */
 OpenLayers.Format.XML = OpenLayers.Class(OpenLayers.Format, {
     
+    /**
+     * Property: namespaces
+     * {Object} Mapping of namespace aliases to namespace URIs.  Properties
+     *     of this object should not be set individually.  Read-only.  All
+     *     XML subclasses should have their own namespaces object.  Use
+     *     <setNamespace> to add or set a namespace alias after construction.
+     */
+    namespaces: null,
+    
+    /**
+     * Property: namespaceAlias
+     * {Object} Mapping of namespace URI to namespace alias.  This object
+     *     is read-only.  Use <setNamespace> to add or set a namespace alias.
+     */
+    namespaceAlias: null,
+    
+    /**
+     * Property: defaultPrefix
+     * {String} The default namespace alias for creating element nodes.
+     */
+    defaultPrefix: null,
+    
+    /**
+     * Property: readers
+     * Contains public functions, grouped by namespace prefix, that will
+     *     be applied when a namespaced node is found matching the function
+     *     name.  The function will be applied in the scope of this parser
+     *     with two arguments: the node being read and a context object passed
+     *     from the parent.
+     */
+    readers: {},
+    
+    /**
+     * Property: writers
+     * As a compliment to the <readers> property, this structure contains public
+     *     writing functions grouped by namespace alias and named like the
+     *     node names they produce.
+     */
+    writers: {},
+
     /**
      * Property: xmldom
      * {XMLDom} If this browser uses ActiveX, this will be set to a XMLDOM
@@ -44,6 +84,34 @@ OpenLayers.Format.XML = OpenLayers.Class(OpenLayers.Format, {
             this.xmldom = new ActiveXObject("Microsoft.XMLDOM");
         }
         OpenLayers.Format.prototype.initialize.apply(this, [options]);
+        // clone the namespace object and set all namespace aliases
+        this.namespaces = OpenLayers.Util.extend({}, this.namespaces);
+        this.namespaceAlias = {};
+        for(var alias in this.namespaces) {
+            this.namespaceAlias[this.namespaces[alias]] = alias;
+        }
+    },
+    
+    /**
+     * APIMethod: destroy
+     * Clean up.
+     */
+    destroy: function() {
+        this.xmldom = null;
+        OpenLayers.Format.prototype.destroy.apply(this, arguments);
+    },
+    
+    /**
+     * Method: setNamespace
+     * Set a namespace alias and URI for the format.
+     *
+     * Parameters:
+     * alias - {String} The namespace alias (prefix).
+     * uri - {String} The namespace URI.
+     */
+    setNamespace: function(alias, uri) {
+        this.namespaces[alias] = uri;
+        this.namespaceAlias[uri] = alias;
     },
 
     /**
@@ -289,11 +357,12 @@ OpenLayers.Format.XML = OpenLayers.Class(OpenLayers.Format, {
      * {String} The value of the first child of the given node.
      */
     getChildValue: function(node, def) {
-        var value;
-        if (node && node.firstChild && node.firstChild.nodeValue) { 
-            value = node.firstChild.nodeValue;
-        } else {
-            value = (def != undefined) ? def : "";
+        var value = def || "";
+        if(node) {
+            var child = node.firstChild;
+            if(child) {
+                value = child.nodeValue || value;
+            }
         }
         return value;
     },
@@ -384,6 +453,172 @@ OpenLayers.Format.XML = OpenLayers.Class(OpenLayers.Format, {
         }
     },
 
+    /**
+     * Method: createElementNSPlus
+     * Shorthand for creating namespaced elements with optional attributes and
+     *     child text nodes.
+     *
+     * Parameters:
+     * name - {String} The qualified node name.
+     * options - {Object} Optional object for node configuration.
+     *
+     * Valid options:
+     * uri - {String} Optional namespace uri for the element - supply a prefix
+     *     instead if the namespace uri is a property of the format's namespace
+     *     object.
+     * attributes - {Object} Optional attributes to be set using the
+     *     <setAttributes> method.
+     * value - {String} Optional text to be appended as a text node.
+     *
+     * Returns:
+     * {Element} An element node.
+     */
+    createElementNSPlus: function(name, options) {
+        options = options || {};
+        var loc = name.indexOf(":");
+        // order of prefix preference
+        // 1. in the uri option
+        // 2. in the prefix option
+        // 3. in the qualified name
+        // 4. from the defaultPrefix
+        var uri = options.uri || this.namespaces[options.prefix];
+        if(!uri) {
+            loc = name.indexOf(":");
+            uri = this.namespaces[name.substring(0, loc)];
+        }
+        if(!uri) {
+            uri = this.namespaces[this.defaultPrefix];
+        }
+        var node = this.createElementNS(uri, name);
+        if(options.attributes) {
+            this.setAttributes(node, options.attributes);
+        }
+        if(options.value) {
+            node.appendChild(this.createTextNode(options.value));
+        }
+        return node;
+    },
+    
+    /**
+     * Method: setAttributes
+     * Set multiple attributes given key value pairs from an object.
+     *
+     * Parameters:
+     * node - {Element} An element node.
+     * obj - {Object || Array} An object whose properties represent attribute
+     *     names and values represent attribute values.  If an attribute name
+     *     is a qualified name ("prefix:local"), the prefix will be looked up
+     *     in the parsers {namespaces} object.  If the prefix is found,
+     *     setAttributeNS will be used instead of setAttribute.
+     */
+    setAttributes: function(node, obj) {
+        var value, loc, alias, uri;
+        for(var name in obj) {
+            if(obj[name] != null && obj[name].toString) {
+                value = obj[name].toString();
+                // check for qualified attribute name ("prefix:local")
+                uri = this.namespaces[name.substring(0, name.indexOf(":"))] || null;
+                this.setAttributeNS(node, uri, name, value);
+            }
+        }
+    },
+
+    /**
+     * Method: readNode
+     * Shorthand for applying one of the named readers given the node
+     *     namespace and local name.  Readers take two args (node, obj) and
+     *     generally extend or modify the second.
+     *
+     * Parameters:
+     * node - {DOMElement} The node to be read (required).
+     * obj - {Object} The object to be modified (optional).
+     *
+     * Returns:
+     * {Object} The input object, modified (or a new one if none was provided).
+     */
+    readNode: function(node, obj) {
+        if(!obj) {
+            obj = {};
+        }
+        var group = this.readers[this.namespaceAlias[node.namespaceURI]];
+        if(group) {
+            var local = node.localName || node.nodeName.split(":").pop();
+            var reader = group[local] || group["*"];
+            if(reader) {
+                reader.apply(this, [node, obj]);
+            }
+        }
+        return obj;
+    },
+
+    /**
+     * Method: readChildNodes
+     * Shorthand for applying the named readers to all children of a node.
+     *     For each child of type 1 (element), <readSelf> is called.
+     *
+     * Parameters:
+     * node - {DOMElement} The node to be read (required).
+     * obj - {Object} The object to be modified (optional).
+     *
+     * Returns:
+     * {Object} The input object, modified.
+     */
+    readChildNodes: function(node, obj) {
+        if(!obj) {
+            obj = {};
+        }
+        var children = node.childNodes;
+        var child;
+        for(var i=0, len=children.length; i<len; ++i) {
+            child = children[i];
+            if(child.nodeType == 1) {
+                this.readNode(child, obj);
+            }
+        }
+        return obj;
+    },
+
+    /**
+     * Method: writeNode
+     * Shorthand for applying one of the named writers and appending the
+     *     results to a node.  If a qualified name is not provided for the
+     *     second argument (and a local name is used instead), the namespace
+     *     of the parent node will be assumed.
+     *
+     * Parameters:
+     * name - {String} The name of a node to generate.  If a qualified name
+     *     (e.g. "pre:Name") is used, the namespace prefix is assumed to be
+     *     in the <writers> group.  If a local name is used (e.g. "Name") then
+     *     the namespace of the parent is assumed.  If a local name is used
+     *     and no parent is supplied, then the default namespace is assumed.
+     * obj - {Object} Structure containing data for the writer.
+     * parent - {DOMElement} Result will be appended to this node.  If no parent
+     *     is supplied, the node will not be appended to anything.
+     *
+     * Returns:
+     * {DOMElement} The child node.
+     */
+    writeNode: function(name, obj, parent) {
+        var prefix, local;
+        var split = name.indexOf(":");
+        if(split > 0) {
+            prefix = name.substring(0, split);
+            local = name.substring(split + 1);
+        } else {
+            if(parent) {
+                prefix = this.namespaceAlias[parent.namespaceURI];
+            } else {
+                prefix = this.defaultPrefix;
+            }
+            local = name;
+        }
+        var child = this.writers[prefix][local].apply(this, [obj]);
+        if(parent) {
+            parent.appendChild(child);
+        }
+        return child;
+    },
+
     CLASS_NAME: "OpenLayers.Format.XML" 
 
 });     
diff --git a/lib/OpenLayers/Layer/TMS.js b/lib/OpenLayers/Layer/TMS.js
index 15d88e246a..8892bb82e8 100644
--- a/lib/OpenLayers/Layer/TMS.js
+++ b/lib/OpenLayers/Layer/TMS.js
@@ -5,6 +5,7 @@
 
 /**
  * @requires OpenLayers/Layer/Grid.js
+ * @requires OpenLayers/Tile/Image.js
  */
 
 /**
diff --git a/lib/OpenLayers/Layer/Vector.js b/lib/OpenLayers/Layer/Vector.js
index 870f6cb566..d27c3f06df 100644
--- a/lib/OpenLayers/Layer/Vector.js
+++ b/lib/OpenLayers/Layer/Vector.js
@@ -38,7 +38,12 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
      * Supported map event types (in addition to those from <OpenLayers.Layer>):
      *  - *beforefeatureadded* Triggered before a feature is added.  Listeners
      *      will receive an object with a *feature* property referencing the
-     *      feature to be added.
+     *      feature to be added.  To stop the feature from being added, a
+     *      listener should return false.
+     *  - *beforefeaturesadded* Triggered before an array of features is added.
+     *      Listeners will receive an object with a *features* property
+     *      referencing the feature to be added. To stop the features from
+     *      being added, a listener should return false.
      *  - *featureadded* Triggered after a feature is added.  The event
      *      object passed to listeners will have a *feature* property with a
      *      reference to the added feature.
@@ -72,7 +77,8 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
      *  - *refresh* Triggered when something wants a strategy to ask the protocol
      *      for a new set of features.
      */
-    EVENT_TYPES: ["beforefeatureadded", "featureadded", "featuresadded",
+    EVENT_TYPES: ["beforefeatureadded", "beforefeaturesadded",
+                  "featureadded", "featuresadded",
                   "beforefeatureremoved", "featureremoved", "featuresremoved",
                   "beforefeatureselected", "featureselected", "featureunselected", 
                   "beforefeaturemodified", "featuremodified", "afterfeaturemodified",
@@ -407,19 +413,14 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
             }
             
             if(!zoomChanged && coordSysUnchanged) {
-                var unrenderedFeatures = {};
                 for(var i in this.unrenderedFeatures) {
                     var feature = this.unrenderedFeatures[i];
-                    if(!this.drawFeature(feature)) {
-                        unrenderedFeatures[i] = feature;
-                    }
+                    this.drawFeature(feature);
                 }
-                this.unrenderedFeatures = unrenderedFeatures;
             }
         }
         
         if (!this.drawn || zoomChanged || !coordSysUnchanged) {
-            this.unrenderedFeatures = {};
             this.drawn = true;
             var feature;
             for(var i=0, len=this.features.length; i<len; i++) {
@@ -429,9 +430,7 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
                     this.renderer.locked = false;
                 }    
                 feature = this.features[i];
-                if (!this.drawFeature(feature)) {
-                    this.unrenderedFeatures[feature.id] = feature;
-                };
+                this.drawFeature(feature);
             }
         }    
     },
@@ -450,6 +449,15 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
         }
         
         var notify = !options || !options.silent;
+        if(notify) {
+            var event = {features: features};
+            var ret = this.events.triggerEvent("beforefeaturesadded", event);
+            if(ret === false) {
+                return;
+            }
+            features = event.features;
+        }
+        
 
         for (var i=0, len=features.length; i<len; i++) {
             if (i != (features.length - 1)) {
@@ -476,16 +484,15 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
             }
 
             if (notify) {
-                this.events.triggerEvent("beforefeatureadded", {
-                    feature: feature
-                });
+                if(this.events.triggerEvent("beforefeatureadded",
+                                            {feature: feature}) === false) {
+                    continue;
+                };
                 this.preFeatureInsert(feature);
             }
 
             if (this.drawn) {
-                if(!this.drawFeature(feature)) {
-                    this.unrenderedFeatures[feature.id] = feature;
-                }
+                this.drawFeature(feature);
             }
             
             if (notify) {
@@ -603,10 +610,6 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
      * Parameters: 
      * feature - {<OpenLayers.Feature.Vector>} 
      * style - {Object} Symbolizer hash or {String} renderIntent
-     * 
-     * Returns:
-     * {Boolean} true if the renderer was able to draw the feature, false
-     *     otherwise
      */
     drawFeature: function(feature, style) {
         if (typeof style != "object") {
@@ -618,7 +621,11 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
             }
         }
         
-        return this.renderer.drawFeature(feature, style);
+        if (!this.renderer.drawFeature(feature, style)) {
+            this.unrenderedFeatures[feature.id] = feature;
+        } else {
+            delete this.unrenderedFeatures[feature.id];
+        };
     },
     
     /**
diff --git a/lib/OpenLayers/Map.js b/lib/OpenLayers/Map.js
index b3358db739..c640895dd6 100644
--- a/lib/OpenLayers/Map.js
+++ b/lib/OpenLayers/Map.js
@@ -167,7 +167,14 @@ OpenLayers.Map = OpenLayers.Class({
 
     /**
      * Property: controls
-     * {Array(<OpenLayers.Control>)} List of controls associated with the map
+     * {Array(<OpenLayers.Control>)} List of controls associated with the map.
+     *
+     * If not provided in the map options at construction, the map will
+     *     be given the following controls by default:
+     *  - <OpenLayers.Control.Navigation>
+     *  - <OpenLayers.Control.PanZoom>
+     *  - <OpenLayers.Control.ArgParser>
+     *  - <OpenLayers.Control.Attribution>
      */
     controls: null,
 
diff --git a/lib/OpenLayers/Protocol/HTTP.js b/lib/OpenLayers/Protocol/HTTP.js
index 866c8e318e..76c5fbc83d 100644
--- a/lib/OpenLayers/Protocol/HTTP.js
+++ b/lib/OpenLayers/Protocol/HTTP.js
@@ -112,6 +112,15 @@ OpenLayers.Protocol.HTTP = OpenLayers.Class(OpenLayers.Protocol, {
      * options - {Object} Optional object for configuring the request.
      *     This object is modified and should not be reused.
      *
+     * Valid options:
+     * url - {String} Url for the request.
+     * params - {Object} Parameters to get serialized as a query string.
+     * headers - {Object} Headers to be set on the request.
+     * filter - {<OpenLayers.Filter.BBOX>} If a bbox filter is sent, it will be
+     *     serialized according to the OpenSearch Geo extension
+     *     (bbox=minx,miny,maxx,maxy).  Note that a BBOX filter as the child
+     *     of a logical filter will not be serialized.
+     *
      * Returns:
      * {<OpenLayers.Protocol.Response>} A response object, whose "priv" property
      *     references the HTTP request, this object is also passed to the
@@ -121,6 +130,14 @@ OpenLayers.Protocol.HTTP = OpenLayers.Class(OpenLayers.Protocol, {
     read: function(options) {
         options = OpenLayers.Util.applyDefaults(options, this.options);
         var resp = new OpenLayers.Protocol.Response({requestType: "read"});
+        
+        if(options.filter && options.filter instanceof OpenLayers.Filter.Spatial) {
+            if(options.filter.type == OpenLayers.Filter.Spatial.BBOX) {
+                options.params = OpenLayers.Util.extend(options.params, {
+                    bbox: options.filter.value.toArray()
+                });
+            }
+        }
 
         resp.priv = OpenLayers.Request.GET({
             url: options.url,
diff --git a/lib/OpenLayers/Protocol/SQL.js b/lib/OpenLayers/Protocol/SQL.js
new file mode 100644
index 0000000000..27072cb0b0
--- /dev/null
+++ b/lib/OpenLayers/Protocol/SQL.js
@@ -0,0 +1,87 @@
+/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
+ * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the
+ * full text of the license. */
+
+/**
+ * @requires OpenLayers/Protocol.js
+ */
+
+/**
+ * Class: OpenLayers.Protocol.SQL
+ * Abstract SQL protocol class.  Not to be instantiated directly.  Use
+ *     one of the SQL protocol subclasses instead.
+ *
+ * Inherits from:
+ *  - <OpenLayers.Protocol>
+ */
+OpenLayers.Protocol.SQL = OpenLayers.Class(OpenLayers.Protocol, {
+
+    /**
+     * APIProperty: databaseName
+     * {String}
+     */
+    databaseName: 'ol',
+
+    /**
+     * APIProperty: tableName
+     * Name of the database table into which Features should be saved.
+     */
+    tableName: "ol_vector_features",
+
+    /**
+     * Property: postReadFiltering
+     * {Boolean} Whether the filter (if there's one) must be applied after
+     *      the features have been read from the database; for example the
+     *      BBOX strategy passes the read method a BBOX spatial filter, if
+     *      postReadFiltering is true every feature read from the database
+     *      will go through the BBOX spatial filter, which can be costly;
+     *      defaults to true.
+     */
+    postReadFiltering: true,
+
+    /**
+     * Constructor: OpenLayers.Protocol.SQL
+     */
+    initialize: function(options) {
+        OpenLayers.Protocol.prototype.initialize.apply(this, [options]);
+    },
+
+    /**
+     * APIMethod: destroy
+     * Clean up the protocol.
+     */
+    destroy: function() {
+        OpenLayers.Protocol.prototype.destroy.apply(this);
+    },
+
+    /**
+     * APIMethod: supported
+     * This should be overridden by specific subclasses
+     *
+     * Returns:
+     * {Boolean} Whether or not the browser supports the SQL backend
+     */
+    supported: function() {
+        return false;
+    },
+
+    /**
+     * Method: evaluateFilter
+     * If postReadFiltering is true evaluate the filter against the feature
+     * and return the result of the evaluation, otherwise return true.
+     *
+     * Parameters:
+     * {<OpenLayers.Feature.Vector>} The feature.
+     * {<OpenLayers.Filter>} The filter.
+     *
+     * Returns:
+     * {Boolean} true if postReadFiltering if false, the result of the
+     * filter evaluation otherwise.
+     */
+    evaluateFilter: function(feature, filter) {
+        return filter && this.postReadFiltering ?
+            filter.evaluate(feature) : true;
+    },
+
+    CLASS_NAME: "OpenLayers.Protocol.SQL"
+});
diff --git a/lib/OpenLayers/Protocol/SQL/Gears.js b/lib/OpenLayers/Protocol/SQL/Gears.js
new file mode 100644
index 0000000000..0c76b3d4ba
--- /dev/null
+++ b/lib/OpenLayers/Protocol/SQL/Gears.js
@@ -0,0 +1,559 @@
+/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
+ * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the
+ * full text of the license. */
+
+/**
+ * @requires Gears/gears_init.js
+ * @requires OpenLayers/Protocol/SQL.js
+ * @requires OpenLayers/Format/JSON.js
+ * @requires OpenLayers/Format/WKT.js
+ */
+
+/**
+ * Class: OpenLayers.Protocol.SQL.Gears
+ * This Protocol stores feature in the browser via the Gears Database module 
+ * <http://code.google.com/apis/gears/api_database.html>.
+ *
+ * The main advantage is that all the read, create, update and delete operations 
+ * can be done offline.
+ *
+ * Inherits from:
+ *  - <OpenLayers.Protocol.SQL>
+ */
+OpenLayers.Protocol.SQL.Gears = OpenLayers.Class(OpenLayers.Protocol.SQL, {
+
+    /**
+     * Property: FID_PREFIX
+     * {String}
+     */
+    FID_PREFIX: '__gears_fid__',
+
+    /**
+     * Property: NULL_GEOMETRY
+     * {String}
+     */
+    NULL_GEOMETRY: '__gears_null_geometry__',
+
+    /**
+     * Property: NULL_FEATURE_STATE
+     * {String}
+     */
+    NULL_FEATURE_STATE: '__gears_null_feature_state__',
+
+    /**
+     * Property: jsonParser
+     * {<OpenLayers.Format.JSON>}
+     */
+    jsonParser: null,
+
+    /**
+     * Property: wktParser
+     * {<OpenLayers.Format.WKT>}
+     */
+    wktParser: null,
+
+    /**
+     * Property: fidRegExp
+     * {RegExp} Regular expression to know whether a feature was
+     *      created in offline mode.
+     */
+    fidRegExp: null,
+
+    /**
+     * Property: saveFeatureState
+     * {Boolean} Whether to save the feature state (<OpenLayers.State>)
+     *      into the database, defaults to true.
+     */    
+    saveFeatureState: true,
+
+    /**
+     * Property: typeOfFid
+     * {String} The type of the feature identifier, either "number" or
+     *      "string", defaults to "string".
+     */
+    typeOfFid: "string",
+
+    /**
+     * Property: db
+     * {GearsDatabase}
+     */
+    db: null,
+
+    /**
+     * Constructor: OpenLayers.Protocol.SQL.Gears
+     */
+    initialize: function(options) {
+        if (!this.supported()) {
+            return;
+        }
+        OpenLayers.Protocol.SQL.prototype.initialize.apply(this, [options]);
+        this.jsonParser = new OpenLayers.Format.JSON();
+        this.wktParser = new OpenLayers.Format.WKT();
+
+        this.fidRegExp = new RegExp('^' + this.FID_PREFIX);
+        this.initializeDatabase();
+
+        
+    },
+
+    /**
+     * Method: initializeDatabase
+     */
+    initializeDatabase: function() {
+        this.db = google.gears.factory.create('beta.database');
+        this.db.open(this.databaseName);
+        this.db.execute(
+            "CREATE TABLE IF NOT EXISTS " + this.tableName +
+            " (fid TEXT UNIQUE, geometry TEXT, properties TEXT," +
+            "  state TEXT)");
+   },
+
+    /**
+     * APIMethod: destroy
+     * Clean up the protocol.
+     */
+    destroy: function() {
+        this.db.close();
+        this.db = null;
+
+        this.jsonParser = null;
+        this.wktParser = null;
+
+        OpenLayers.Protocol.SQL.prototype.destroy.apply(this);
+    },
+
+    /**
+     * APIMethod: supported
+     * Determine whether a browser supports Gears
+     *
+     * Returns:
+     * {Boolean} The browser supports Gears
+     */
+    supported: function() {
+        return !!(window.google && google.gears);
+    },
+
+    /**
+     * Method: read
+     * Read all features from the database and return a
+     * <OpenLayers.Protocol.Response> instance. If the options parameter
+     * contains a callback attribute, the function is called with the response
+     * as a parameter.
+     *
+     * Parameters:
+     * options - {Object} Optional object for configuring the request; it
+     *      can have the {Boolean} property "noFeatureStateReset" which
+     *      specifies if the state of features read from the Gears
+     *      database must be reset to null, if "noFeatureStateReset"
+     *      is undefined or false then each feature's state is reset
+     *      to null, if "noFeatureStateReset" is true the feature state
+     *      is preserved.
+     *
+     * Returns:
+     * {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response>
+     *      object.
+     */
+    read: function(options) {
+        options = OpenLayers.Util.applyDefaults(options, this.options);
+
+        var feature, features = [];
+        var rs = this.db.execute("SELECT * FROM " + this.tableName);
+        while (rs.isValidRow()) {
+            feature = this.unfreezeFeature(rs);
+            if (this.evaluateFilter(feature, options.filter)) {
+                if (!options.noFeatureStateReset) {
+                    feature.state = null;
+                }
+                features.push(feature);
+            }
+            rs.next();
+        }
+        rs.close();
+
+        var resp = new OpenLayers.Protocol.Response({
+            code: OpenLayers.Protocol.Response.SUCCESS,
+            requestType: "read",
+            features: features
+        });
+
+        if (options && options.callback) {
+            options.callback.call(options.scope, resp);
+        }
+
+        return resp;
+    },
+
+    /**
+     * Method: unfreezeFeature
+     *
+     * Parameters:
+     * row - {ResultSet}
+     *
+     * Returns:
+     * {<OpenLayers.Feature.Vector>}
+     */
+    unfreezeFeature: function(row) {
+        var feature;
+        var wkt = row.fieldByName('geometry');
+        if (wkt == this.NULL_GEOMETRY) {
+            feature = new OpenLayers.Feature.Vector();
+        } else {
+            feature = this.wktParser.read(wkt);
+        }
+
+        feature.attributes = this.jsonParser.read(
+            row.fieldByName('properties'));
+
+        feature.fid = this.extractFidFromField(row.fieldByName('fid'));
+
+        var state = row.fieldByName('state');
+        if (state == this.NULL_FEATURE_STATE) {
+            state = null;
+        }
+        feature.state = state;
+
+        return feature;
+    },
+
+    /**
+     * Method: extractFidFromField
+     *
+     * Parameters:
+     * field - {String}
+     *
+     * Returns
+     * {String} or {Number} The fid.
+     */
+    extractFidFromField: function(field) {
+        if (!field.match(this.fidRegExp) && this.typeOfFid == "number") {
+            field = parseFloat(field);
+        }
+        return field;
+    },
+
+    /**
+     * Method: create
+     * Create new features into the database.
+     *
+     * Parameters:
+     * features - {Array({<OpenLayers.Feature.Vector>})} or
+     *            {<OpenLayers.Feature.Vector>} The features to create in
+     *            the database.
+     * options - {Object} Optional object for configuring the request.
+     *
+     * Returns:
+     *  {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response>
+     *          object.
+     */
+    create: function(features, options) {
+        options = OpenLayers.Util.applyDefaults(options, this.options);
+
+        var resp = this.createOrUpdate(features);
+        resp.requestType = "create";
+
+        if (options && options.callback) {
+            options.callback.call(options.scope, resp);
+        }
+
+        return resp;
+    },
+
+    /**
+     * Method: update
+     * Construct a request updating modified feature.
+     *
+     * Parameters:
+     * features - {Array({<OpenLayers.Feature.Vector>})} or
+     *            {<OpenLayers.Feature.Vector>} The features to update in
+     *            the database.
+     * options - {Object} Optional object for configuring the request.
+     *
+     * Returns:
+     *  {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response>
+     *          object.
+     */
+    update: function(features, options) {
+        options = OpenLayers.Util.applyDefaults(options, this.options);
+
+        var resp = this.createOrUpdate(features);
+        resp.requestType = "update";
+
+        if (options && options.callback) {
+            options.callback.call(options.scope, resp);
+        }
+
+        return resp;
+    },
+
+    /**
+     * Method: createOrUpdate
+     * Construct a request for updating or creating features in the
+     * database.
+     *
+     * Parameters:
+     * features - {Array({<OpenLayers.Feature.Vector>})} or
+     *      {<OpenLayers.Feature.Vector>} The feature to create or update
+     *      in the database.
+     *
+     * Returns:
+     *  {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response>
+     *          object.
+     */
+    createOrUpdate: function(features) {
+        if (!(features instanceof Array)) {
+            features = [features];
+        }
+
+        var i, len = features.length, feature;
+        var insertedFeatures = new Array(len);
+ 
+        for (i = 0; i < len; i++) {
+            feature = features[i];
+            var params = this.freezeFeature(feature);
+            this.db.execute(
+                "REPLACE INTO " + this.tableName + 
+                " (fid, geometry, properties, state)" + 
+                " VALUES (?, ?, ?, ?)",
+                params);
+
+            var clone = feature.clone();
+            clone.fid = this.extractFidFromField(params[0]);
+            insertedFeatures[i] = clone;
+        }
+
+        return new OpenLayers.Protocol.Response({
+            code: OpenLayers.Protocol.Response.SUCCESS,
+            features: insertedFeatures,
+            reqFeatures: features
+        });
+    },
+
+    /**
+     * Method: freezeFeature
+     *
+     * Parameters:
+     * feature - {<OpenLayers.Feature.Vector>}
+     * state - {String} The feature state to store in the database.
+     *
+     * Returns:
+     * {Array}
+     */
+    freezeFeature: function(feature) {
+        // 2 notes:
+        // - fid might not be a string
+        // - getFeatureStateForFreeze needs the feature fid to it's stored
+        //   in the feature here
+        feature.fid = feature.fid != null ?
+            "" + feature.fid : OpenLayers.Util.createUniqueID(this.FID_PREFIX);
+
+        var geometry = feature.geometry != null ?
+            feature.geometry.toString() : this.NULL_GEOMETRY;
+
+        var properties = this.jsonParser.write(feature.attributes);
+
+        var state = this.getFeatureStateForFreeze(feature);
+
+        return [feature.fid, geometry, properties, state];
+    },
+
+    /**
+     * Method: getFeatureStateForFreeze
+     * Get the state of the feature to store into the database.
+     *
+     * Parameters:
+     * feature - {<OpenLayers.Feature.Vector>} The feature.
+     *
+     * Returns
+     * {String} The state
+     */
+    getFeatureStateForFreeze: function(feature) {
+        var state;
+        if (!this.saveFeatureState) {
+            state = this.NULL_FEATURE_STATE;
+        } else if (this.createdOffline(feature)) {
+            // if the feature was created in offline mode, its
+            // state must remain INSERT
+            state = OpenLayers.State.INSERT;
+        } else {
+            state = feature.state;
+        }
+        return state;
+    },
+
+    /**
+     * Method: delete
+     * Delete features from the database.
+     *
+     * Parameters:
+     * features - {Array({<OpenLayers.Feature.Vector>})} or
+     *            {<OpenLayers.Feature.Vector>}
+     * options - {Object} Optional object for configuring the request.
+     *       This object is modified and should not be reused.
+     *
+     * Returns:
+     *  {<OpenLayers.Protocol.Response>} An <OpenLayers.Protocol.Response>
+     *          object.
+     */
+    "delete": function(features, options) {
+        if (!(features instanceof Array)) {
+            features = [features];
+        }
+
+        options = OpenLayers.Util.applyDefaults(options, this.options);
+
+        var i, len, feature;
+        for (i = 0, len = features.length; i < len; i++) {
+            feature = features[i];
+
+            // if saveFeatureState is set to true and if the feature wasn't created
+            // in offline mode we don't delete it in the database but just update 
+            // it state column
+            if (this.saveFeatureState && !this.createdOffline(feature)) {
+                var toDelete = feature.clone();
+                toDelete.fid = feature.fid;
+                if (toDelete.geometry) {
+                    toDelete.geometry.destroy();
+                    toDelete.geometry = null;
+                }
+                toDelete.state = feature.state;
+                this.createOrUpdate(toDelete);
+            } else {
+                this.db.execute(
+                    "DELETE FROM " + this.tableName +
+                    " WHERE fid = ?", [feature.fid]);
+            }
+        }
+
+        var resp = new OpenLayers.Protocol.Response({
+            code: OpenLayers.Protocol.Response.SUCCESS,
+            requestType: "delete",
+            reqFeatures: features
+        });
+
+        if (options && options.callback) {
+            options.callback.call(options.scope, resp);
+        }
+
+        return resp;
+    },
+
+    /**
+     * Method: createdOffline
+     * Returns true if the feature had a feature id when it was created in
+     *      the Gears database, false otherwise; this is determined by
+     *      checking the form of the feature's fid value.
+     *
+     * Parameters:
+     * feature - {<OpenLayers.Feature.Vector>}
+     *
+     * Returns:
+     * {Boolean}
+     */
+    createdOffline: function(feature) {
+        return (typeof feature.fid == "string" &&
+                !!(feature.fid.match(this.fidRegExp)));
+    },
+
+    /**
+     * Method: commit
+     * Go over the features and for each take action
+     * based on the feature state. Possible actions are create,
+     * update and delete.
+     *
+     * Parameters:
+     * features - {Array({<OpenLayers.Feature.Vector>})}
+     * options - {Object} Object whose possible keys are "create", "update",
+     *      "delete", "callback" and "scope", the values referenced by the
+     *      first three are objects as passed to the "create", "update", and
+     *      "delete" methods, the value referenced by the "callback" key is
+     *      a function which is called when the commit operation is complete
+     *      using the scope referenced by the "scope" key.
+     *
+     * Returns:
+     * {Array({<OpenLayers.Protocol.Response>})} An array of
+     *       <OpenLayers.Protocol.Response> objects, one per request made
+     *       to the database.
+     */
+    commit: function(features, options) {
+        var opt, resp = [], nRequests = 0, nResponses = 0;
+
+        function callback(resp) {
+            if (++nResponses < nRequests) {
+                resp.last = false;
+            }
+            this.callUserCallback(options, resp);
+        }
+
+        var feature, toCreate = [], toUpdate = [], toDelete = [];
+        for (var i = features.length - 1; i >= 0; i--) {
+            feature = features[i];
+            switch (feature.state) {
+            case OpenLayers.State.INSERT:
+                toCreate.push(feature);
+                break;
+            case OpenLayers.State.UPDATE:
+                toUpdate.push(feature);
+                break;
+            case OpenLayers.State.DELETE:
+                toDelete.push(feature);
+                break;
+            }
+        }
+        if (toCreate.length > 0) {
+            nRequests++;
+            opt = OpenLayers.Util.applyDefaults(
+                {"callback": callback, "scope": this},
+                options.create
+            );
+            resp.push(this.create(toCreate, opt));
+        }
+        if (toUpdate.length > 0) {
+            nRequests++;
+            opt = OpenLayers.Util.applyDefaults(
+                {"callback": callback, "scope": this},
+                options.update
+            );
+            resp.push(this.update(toUpdate, opt));
+        }
+        if (toDelete.length > 0) {
+            nRequests++;
+            opt = OpenLayers.Util.applyDefaults(
+                {"callback": callback, "scope": this},
+                options["delete"]
+            );
+            resp.push(this["delete"](toDelete, opt));
+        }
+
+        return resp;
+    },
+
+    /**
+     * Method: clear
+     * Removes all rows of the table.
+     */
+    clear: function() {
+        this.db.execute("DELETE FROM " + this.tableName);
+    },
+
+    /**
+     * Method: callUserCallback
+     * This method is called from within commit each time a request is made
+     * to the database, it is responsible for calling the user-supplied
+     * callbacks.
+     *
+     * Parameters:
+     * options - {Object} The map of options passed to the commit call.
+     * resp - {<OpenLayers.Protocol.Response>}
+     */
+    callUserCallback: function(options, resp) {
+        var opt = options[resp.requestType];
+        if (opt && opt.callback) {
+            opt.callback.call(opt.scope, resp);
+        }
+        if (resp.last && options.callback) {
+            options.callback.call(options.scope);
+        }
+    },
+
+    CLASS_NAME: "OpenLayers.Protocol.SQL.Gears"
+});
diff --git a/lib/OpenLayers/Renderer/Elements.js b/lib/OpenLayers/Renderer/Elements.js
index 40a21e8155..ec209e6ccb 100644
--- a/lib/OpenLayers/Renderer/Elements.js
+++ b/lib/OpenLayers/Renderer/Elements.js
@@ -810,7 +810,9 @@ OpenLayers.Renderer.Elements = OpenLayers.Class(OpenLayers.Renderer, {
 
                 if (this.indexer) {
                     this.indexer.remove(element);
-                    
+                }
+                
+                if (element._style.backgroundGraphic) {
                     var backgroundId = geometry.id + this.BACKGROUND_ID_SUFFIX;
                     var bElem = OpenLayers.Util.getElement(backgroundId);
                     if (bElem && bElem.parentNode) {
diff --git a/lib/OpenLayers/Renderer/SVG.js b/lib/OpenLayers/Renderer/SVG.js
index cf66273cb7..807c09973a 100644
--- a/lib/OpenLayers/Renderer/SVG.js
+++ b/lib/OpenLayers/Renderer/SVG.js
@@ -153,7 +153,7 @@ OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, {
      * y - {Float}
      * 
      * Returns:
-     * {Boolean} true if the translation parameters ar in the valid coordinates
+     * {Boolean} true if the translation parameters are in the valid coordinates
      *     range, false otherwise.
      */
     translate: function(x, y) {
diff --git a/lib/OpenLayers/Renderer/VML.js b/lib/OpenLayers/Renderer/VML.js
index 76333dd971..33d773322c 100644
--- a/lib/OpenLayers/Renderer/VML.js
+++ b/lib/OpenLayers/Renderer/VML.js
@@ -33,6 +33,12 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
      */
     symbolCache: {},
 
+    /**
+     * Property: offset
+     * {Object} Hash with "x" and "y" properties
+     */
+    offset: null,
+    
     /**
      * Constructor: OpenLayers.Renderer.VML
      * Create a new VML renderer.
@@ -50,8 +56,10 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
             style.addRule('olv\\:*', "behavior: url(#default#VML); " +
                                    "position: absolute; display: inline-block;");
         }
+        
         OpenLayers.Renderer.Elements.prototype.initialize.apply(this, 
                                                                 arguments);
+        this.offset = {x: 0, y: 0};
     },
 
     /**
@@ -90,8 +98,18 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
                                                                arguments);
         var resolution = this.getResolution();
     
-        var org = extent.left/resolution + " " + 
-                    (extent.top/resolution - this.size.h);
+        var left = extent.left/resolution;
+        var top = extent.top/resolution - this.size.h;
+        if (resolutionChanged) {
+            this.offset = {x: left, y: top};
+            left = 0;
+            top = 0;
+        } else {
+            left = left - this.offset.x;
+            top = top - this.offset.y;
+        }
+        
+        var org = left + " " + top;
         this.root.setAttribute("coordorigin", org);
 
         var size = this.size.w + " " + this.size.h;
@@ -191,8 +209,8 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
                 var yOffset = (style.graphicYOffset != undefined) ?
                     style.graphicYOffset : -(0.5 * height);
                 
-                node.style.left = ((geometry.x/resolution)+xOffset).toFixed();
-                node.style.top = ((geometry.y/resolution)-(yOffset+height)).toFixed();
+                node.style.left = ((geometry.x/resolution - this.offset.x)+xOffset).toFixed();
+                node.style.top = ((geometry.y/resolution - this.offset.y)-(yOffset+height)).toFixed();
                 node.style.width = width + "px";
                 node.style.height = height + "px";
                 node.style.flip = "y";
@@ -448,10 +466,10 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
             var resolution = this.getResolution();
         
             var scaledBox = 
-                new OpenLayers.Bounds((bbox.left/resolution).toFixed(),
-                                      (bbox.bottom/resolution).toFixed(),
-                                      (bbox.right/resolution).toFixed(),
-                                      (bbox.top/resolution).toFixed());
+                new OpenLayers.Bounds((bbox.left/resolution - this.offset.x).toFixed(),
+                                      (bbox.bottom/resolution - this.offset.y).toFixed(),
+                                      (bbox.right/resolution - this.offset.x).toFixed(),
+                                      (bbox.top/resolution - this.offset.y).toFixed());
             
             // Set the internal coordinate system to draw the path
             node.style.left = scaledBox.left + "px";
@@ -613,9 +631,9 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
     drawCircle: function(node, geometry, radius) {
         if(!isNaN(geometry.x)&& !isNaN(geometry.y)) {
             var resolution = this.getResolution();
-        
-            node.style.left = ((geometry.x /resolution).toFixed() - radius) + "px";
-            node.style.top = ((geometry.y /resolution).toFixed() - radius) + "px";
+
+            node.style.left = ((geometry.x /resolution - this.offset.x).toFixed() - radius) + "px";
+            node.style.top = ((geometry.y /resolution - this.offset.y).toFixed() - radius) + "px";
     
             var diameter = radius * 2;
             
@@ -680,8 +698,8 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
         var comp, x, y;
         for (var i = 0; i < numComponents; i++) {
             comp = geometry.components[i];
-            x = (comp.x/resolution);
-            y = (comp.y/resolution);
+            x = (comp.x/resolution - this.offset.x);
+            y = (comp.y/resolution - this.offset.y);
             parts[i] = " " + x.toFixed() + "," + y.toFixed() + " l ";
         }
         var end = (closeLine) ? " x e" : " e";
@@ -713,8 +731,8 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
             path.push("m");
             for (i=0, ilen=linearRing.components.length; i<ilen; i++) {
                 comp = linearRing.components[i];
-                x = comp.x / resolution;
-                y = comp.y / resolution;
+                x = comp.x / resolution - this.offset.x;
+                y = comp.y / resolution - this.offset.y;
                 path.push(" " + x.toFixed() + "," + y.toFixed());
                 if (i==0) {
                     path.push(" l");
@@ -741,8 +759,8 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
     drawRectangle: function(node, geometry) {
         var resolution = this.getResolution();
     
-        node.style.left = geometry.x/resolution + "px";
-        node.style.top = geometry.y/resolution + "px";
+        node.style.left = (geometry.x/resolution - this.offset.x) + "px";
+        node.style.top = (geometry.y/resolution - this.offset.y) + "px";
         node.style.width = geometry.width/resolution + "px";
         node.style.height = geometry.height/resolution + "px";
         
@@ -769,8 +787,8 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
         var comp, x, y;
         for (var i=0, len=geometry.components.length; i<len; i++) {
             comp = geometry.components[i];
-            x = comp.x / resolution;
-            y = comp.y / resolution;
+            x = comp.x / resolution - this.offset.x;
+            y = comp.y / resolution - this.offset.y;
             if ((i%3)==0 && (i/3)==0) {
                 path.push("m");
             } else if ((i%3)==1) {
diff --git a/lib/OpenLayers/Request.js b/lib/OpenLayers/Request.js
index 2cf595d8d6..e0ca23a1b4 100644
--- a/lib/OpenLayers/Request.js
+++ b/lib/OpenLayers/Request.js
@@ -87,7 +87,11 @@ OpenLayers.Request = {
         var request = new OpenLayers.Request.XMLHttpRequest();
         var url = config.url;
         if(config.params) {
-            url += "?" + OpenLayers.Util.getParameterString(config.params);
+            var paramString = OpenLayers.Util.getParameterString(config.params);
+            if(paramString.length > 0) {
+                var separator = (url.indexOf('?') > -1) ? '&' : '?';
+                url += separator + paramString;
+            }
         }
         if(config.proxy && (url.indexOf("http") == 0)) {
             url = config.proxy + encodeURIComponent(url);
@@ -265,4 +269,4 @@ OpenLayers.Request = {
         return OpenLayers.Request.issue(config);
     }
 
-};
\ No newline at end of file
+};
diff --git a/lib/OpenLayers/Strategy/BBOX.js b/lib/OpenLayers/Strategy/BBOX.js
new file mode 100644
index 0000000000..f37fd0154d
--- /dev/null
+++ b/lib/OpenLayers/Strategy/BBOX.js
@@ -0,0 +1,210 @@
+/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
+ * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the
+ * full text of the license. */
+
+/**
+ * @requires OpenLayers/Strategy.js
+ * @requires OpenLayers/Filter/Spatial.js
+ */
+
+/**
+ * Class: OpenLayers.Strategy.BBOX
+ * A simple strategy that reads new features when the viewport invalidates
+ *     some bounds.
+ *
+ * Inherits from:
+ *  - <OpenLayers.Strategy>
+ */
+OpenLayers.Strategy.BBOX = OpenLayers.Class(OpenLayers.Strategy, {
+    
+    /**
+     * Property: bounds
+     * {<OpenLayers.Bounds>} The current data bounds.
+     */
+    bounds: null,
+    
+    /**
+     * Property: ratio
+     * {Float} The ratio of the data bounds to the viewport bounds (in each
+     *     dimension).
+     */
+    ratio: 2,
+
+    /**
+     * Property: response
+     * {<OpenLayers.Protocol.Response>} The protocol response object returned
+     *      by the layer protocol.
+     */
+    response: null,
+
+    /**
+     * Constructor: OpenLayers.Strategy.BBOX
+     * Create a new BBOX strategy.
+     *
+     * Parameters:
+     * options - {Object} Optional object whose properties will be set on the
+     *     instance.
+     */
+    initialize: function(options) {
+        OpenLayers.Strategy.prototype.initialize.apply(this, [options]);
+    },
+    
+    /**
+     * Method: activate
+     * Set up strategy with regard to reading new batches of remote data.
+     * 
+     * Returns:
+     * {Boolean} The strategy was successfully activated.
+     */
+    activate: function() {
+        var activated = OpenLayers.Strategy.prototype.activate.call(this);
+        if(activated) {
+            this.layer.events.on({
+                "moveend": this.update,
+                scope: this
+            });
+            this.layer.events.on({
+                "refresh": this.update,
+                scope: this
+            });
+        }
+        return activated;
+    },
+    
+    /**
+     * Method: deactivate
+     * Tear down strategy with regard to reading new batches of remote data.
+     * 
+     * Returns:
+     * {Boolean} The strategy was successfully deactivated.
+     */
+    deactivate: function() {
+        var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this);
+        if(deactivated) {
+            this.layer.events.un({
+                "moveend": this.update,
+                scope: this
+            });
+            this.layer.events.un({
+                "refresh": this.update,
+                scope: this
+            });
+        }
+        return deactivated;
+    },
+
+    /**
+     * Method: update
+     * Callback function called on "moveend" or "refresh" layer events.
+     *
+     * Parameters:
+     * options - {Object} An object with a property named "force", this
+     *      property references a boolean value indicating if new data
+     *      must be incondtionally read.
+     */
+    update: function(options) {
+        var mapBounds = this.layer.map.getExtent();
+        if ((options && options.force) || this.invalidBounds(mapBounds)) {
+            this.calculateBounds(mapBounds);
+            this.triggerRead();
+        }
+    },
+
+    /**
+     * Method: invalidBounds
+     *
+     * Parameters:
+     * mapBounds - {<OpenLayers.Bounds>} the current map extent, will be
+     *      retrieved from the map object if not provided
+     *
+     * Returns:
+     * {Boolean} 
+     */
+    invalidBounds: function(mapBounds) {
+        if(!mapBounds) {
+            mapBounds = this.layer.map.getExtent();
+        }
+        return !this.bounds || !this.bounds.containsBounds(mapBounds);
+    },
+ 
+    /**
+     * Method: calculateBounds
+     *
+     * Parameters:
+     * mapBounds - {<OpenLayers.Bounds>} the current map extent, will be
+     *      retrieved from the map object if not provided
+     */
+    calculateBounds: function(mapBounds) {
+        if(!mapBounds) {
+            mapBounds = this.layer.map.getExtent();
+        }
+        var center = mapBounds.getCenterLonLat();
+        var dataWidth = mapBounds.getWidth() * this.ratio;
+        var dataHeight = mapBounds.getHeight() * this.ratio;
+        this.bounds = new OpenLayers.Bounds(
+            center.lon - (dataWidth / 2),
+            center.lat - (dataHeight / 2),
+            center.lon + (dataWidth / 2),
+            center.lat + (dataHeight / 2)
+        );
+    },
+    
+    /**
+     * Method: triggerRead
+     *
+     * Returns:
+     * {<OpenLayers.Protocol.Response>} The protocol response object
+     *      returned by the layer protocol.
+     */
+    triggerRead: function() {
+        var filter = this.createFilter();
+        if (this.response && this.response.priv &&
+            typeof this.response.priv.abort == "function") {
+            this.response.priv.abort();
+        }
+        this.response = this.layer.protocol.read({
+            filter: filter,
+            callback: this.merge,
+            scope: this
+        });
+    },
+ 
+    /**
+     * Method: createFilter
+     *
+     * Returns
+     * {<OpenLayers.Filter>} The filter object.
+     */
+    createFilter: function() {
+        var filter = new OpenLayers.Filter.Spatial({
+            type: OpenLayers.Filter.Spatial.BBOX,
+            value: this.bounds,
+            projection: this.layer.projection
+        });
+        if (this.layer.filter) {
+            filter = new OpenLayers.Filter.Logical({
+                type: OpenLayers.Filter.Logical.AND,
+                filters: [this.layer.filter, filter]
+            });
+        }
+        return filter;
+    },
+   
+    /**
+     * Method: merge
+     * Given a list of features, determine which ones to add to the layer.
+     *
+     * Parameters:
+     * resp - {<OpenLayers.Protocol.Response>} The response object passed
+     *      by the protocol.
+     */
+    merge: function(resp) {
+        this.layer.destroyFeatures();
+        var features = resp.features;
+        if(features && features.length > 0) {
+            this.layer.addFeatures(features);
+        }
+    },
+   
+    CLASS_NAME: "OpenLayers.Strategy.BBOX" 
+});
diff --git a/lib/OpenLayers/Strategy/Cluster.js b/lib/OpenLayers/Strategy/Cluster.js
new file mode 100644
index 0000000000..80e4b283f0
--- /dev/null
+++ b/lib/OpenLayers/Strategy/Cluster.js
@@ -0,0 +1,261 @@
+/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
+ * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the
+ * full text of the license. */
+
+/**
+ * @requires OpenLayers/Strategy.js
+ */
+
+/**
+ * Class: OpenLayers.Strategy.Cluster
+ * Strategy for vector feature clustering.
+ *
+ * Inherits from:
+ *  - <OpenLayers.Strategy>
+ */
+OpenLayers.Strategy.Cluster = OpenLayers.Class(OpenLayers.Strategy, {
+    
+    /**
+     * Property: layer
+     * {<OpenLayers.Layer.Vector>} The layer that this strategy is assigned to.
+     */
+    layer: null,
+    
+    /**
+     * APIProperty: distance
+     * {Integer} Pixel distance between features that should be considered a
+     *     single cluster.  Default is 20 pixels.
+     */
+    distance: 20,
+    
+    /**
+     * Property: features
+     * {Array(<OpenLayers.Feature.Vector>)} Cached features.
+     */
+    features: null,
+    
+    /**
+     * Property: clusters
+     * {Array(<OpenLayers.Feature.Vector>)} Calculated clusters.
+     */
+    clusters: null,
+    
+    /**
+     * Property: clustering
+     * {Boolean} The strategy is currently clustering features.
+     */
+    clustering: false,
+    
+    /**
+     * Property: resolution
+     * {Float} The resolution (map units per pixel) of the current cluster set.
+     */
+    resolution: null,
+
+    /**
+     * Constructor: OpenLayers.Strategy.Cluster
+     * Create a new clustering strategy.
+     *
+     * Parameters:
+     * options - {Object} Optional object whose properties will be set on the
+     *     instance.
+     */
+    initialize: function(options) {
+        OpenLayers.Strategy.prototype.initialize.apply(this, [options]);
+    },
+    
+    /**
+     * APIMethod: activate
+     * Activate the strategy.  Register any listeners, do appropriate setup.
+     * 
+     * Returns:
+     * {Boolean} The strategy was successfully activated.
+     */
+    activate: function() {
+        var activated = OpenLayers.Strategy.prototype.activate.call(this);
+        if(activated) {
+            this.layer.events.on({
+                "beforefeaturesadded": this.cacheFeatures,
+                scope: this
+            });
+            this.layer.map.events.on({"zoomend": this.cluster, scope: this});
+        }
+        return activated;
+    },
+    
+    /**
+     * APIMethod: deactivate
+     * Deactivate the strategy.  Unregister any listeners, do appropriate
+     *     tear-down.
+     * 
+     * Returns:
+     * {Boolean} The strategy was successfully deactivated.
+     */
+    deactivate: function() {
+        var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this);
+        if(deactivated) {
+            this.clearCache();
+            this.layer.events.un({
+                "beforefeaturesadded": this.cacheFeatures,
+                scope: this
+            });
+            this.layer.map.events.un({"zoomend": this.cluster, scope: this});
+        }
+        return deactivated;
+    },
+    
+    /**
+     * Method: cacheFeatures
+     * Cache features before they are added to the layer.
+     *
+     * Parameters:
+     * event - {Object} The event that this was listening for.  This will come
+     *     with a batch of features to be clustered.
+     *     
+     * Returns:
+     * {Boolean} False to stop layer from being added to the layer.
+     */
+    cacheFeatures: function(event) {
+        var propagate = true;
+        if(!this.clustering) {
+            this.clearCache();
+            this.features = event.features;
+            this.cluster();
+            propagate = false;
+        }
+        return propagate;
+    },
+    
+    /**
+     * Method: clearCache
+     * Clear out the cached features.  This destroys features, assuming
+     *     nothing else has a reference.
+     */
+    clearCache: function() {
+        if(this.features) {
+            for(var i=0; i<this.features.length; ++i) {
+                this.features[i].destroy();
+            }
+        }
+        this.features = null;
+    },
+    
+    /**
+     * Method: cluster
+     * Cluster features based on some threshold distance.
+     */
+    cluster: function() {
+        if(this.features) {
+            var resolution = this.layer.getResolution();
+            if(resolution != this.resolution || !this.clustersExist()) {
+                this.resolution = resolution;
+                var clusters = [];
+                var feature, clustered, cluster;
+                for(var i=0; i<this.features.length; ++i) {
+                    feature = this.features[i];
+                    clustered = false;
+                    for(var j=0; j<clusters.length; ++j) {
+                        cluster = clusters[j];
+                        if(this.shouldCluster(cluster, feature)) {
+                            this.addToCluster(cluster, feature);
+                            clustered = true;
+                            break;
+                        }
+                    }
+                    if(!clustered) {
+                        clusters.push(this.createCluster(this.features[i]));
+                    }
+                }
+                this.layer.destroyFeatures();
+                if(clusters.length > 0) {
+                    this.clustering = true;
+                    // A legitimate feature addition could occur during this
+                    // addFeatures call.  For clustering to behave well, features
+                    // should be removed from a layer before requesting a new batch.
+                    this.layer.addFeatures(clusters);
+                    this.clustering = false;
+                }
+                this.clusters = clusters;
+            }
+        }
+    },
+    
+    /**
+     * Method: clustersExist
+     * Determine whether calculated clusters are already on the layer.
+     *
+     * Returns:
+     * {Boolean} The calculated clusters are already on the layer.
+     */
+    clustersExist: function() {
+        var exist = false;
+        if(this.clusters && this.clusters.length > 0 &&
+           this.clusters.length == this.layer.features.length) {
+            exist = true;
+            for(var i=0; i<this.clusters.length; ++i) {
+                if(this.clusters[i] != this.layer.features[i]) {
+                    exist = false;
+                    break;
+                }
+            }
+        }
+        return exist;
+    },
+    
+    /**
+     * Method: shouldCluster
+     * Determine whether to include a feature in a given cluster.
+     *
+     * Parameters:
+     * cluster - {<OpenLayers.Feature.Vector>} A cluster.
+     * feature - {<OpenLayers.Feature.Vector>} A feature.
+     *
+     * Returns:
+     * {Boolean} The feature should be included in the cluster.
+     */
+    shouldCluster: function(cluster, feature) {
+        var cc = cluster.geometry.getBounds().getCenterLonLat();
+        var fc = feature.geometry.getBounds().getCenterLonLat();
+        var distance = (
+            Math.sqrt(
+                Math.pow((cc.lon - fc.lon), 2) + Math.pow((cc.lat - fc.lat), 2)
+            ) / this.resolution
+        );
+        return (distance <= this.distance);
+    },
+    
+    /**
+     * Method: addToCluster
+     * Add a feature to a cluster.
+     *
+     * Parameters:
+     * cluster - {<OpenLayers.Feature.Vector>} A cluster.
+     * feature - {<OpenLayers.Feature.Vector>} A feature.
+     */
+    addToCluster: function(cluster, feature) {
+        cluster.cluster.push(feature);
+        cluster.attributes.count += 1;
+    },
+    
+    /**
+     * Method: createCluster
+     * Given a feature, create a cluster.
+     *
+     * Parameters:
+     * feature - {<OpenLayers.Feature.Vector>}
+     *
+     * Returns:
+     * {<OpenLayers.Feature.Vector>} A cluster.
+     */
+    createCluster: function(feature) {
+        var center = feature.geometry.getBounds().getCenterLonLat();
+        var cluster = new OpenLayers.Feature.Vector(
+            new OpenLayers.Geometry.Point(center.lon, center.lat),
+            {count: 1}
+        );
+        cluster.cluster = [feature];
+        return cluster;
+    },
+
+    CLASS_NAME: "OpenLayers.Strategy.Cluster" 
+});
diff --git a/lib/OpenLayers/Strategy/Paging.js b/lib/OpenLayers/Strategy/Paging.js
new file mode 100644
index 0000000000..c3ac684317
--- /dev/null
+++ b/lib/OpenLayers/Strategy/Paging.js
@@ -0,0 +1,241 @@
+/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
+ * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the
+ * full text of the license. */
+
+/**
+ * @requires OpenLayers/Strategy.js
+ */
+
+/**
+ * Class: OpenLayers.Strategy.Paging
+ * Strategy for vector feature paging
+ *
+ * Inherits from:
+ *  - <OpenLayers.Strategy>
+ */
+OpenLayers.Strategy.Paging = OpenLayers.Class(OpenLayers.Strategy, {
+    
+    /**
+     * Property: layer
+     * {<OpenLayers.Layer.Vector>} The layer that this strategy is assigned to.
+     */
+    layer: null,
+    
+    /**
+     * Property: features
+     * {Array(<OpenLayers.Feature.Vector>)} Cached features.
+     */
+    features: null,
+    
+    /**
+     * Property: length
+     * {Integer} Number of features per page.  Default is 10.
+     */
+    length: 10,
+    
+    /**
+     * Property: num
+     * {Integer} The currently displayed page number.
+     */
+    num: null,
+    
+    /**
+     * Property: paging
+     * {Boolean} The strategy is currently changing pages.
+     */
+    paging: false,
+
+    /**
+     * Constructor: OpenLayers.Strategy.Paging
+     * Create a new paging strategy.
+     *
+     * Parameters:
+     * options - {Object} Optional object whose properties will be set on the
+     *     instance.
+     */
+    initialize: function(options) {
+        OpenLayers.Strategy.prototype.initialize.apply(this, [options]);
+    },
+    
+    /**
+     * APIMethod: activate
+     * Activate the strategy.  Register any listeners, do appropriate setup.
+     * 
+     * Returns:
+     * {Boolean} The strategy was successfully activated.
+     */
+    activate: function() {
+        var activated = OpenLayers.Strategy.prototype.activate.call(this);
+        if(activated) {
+            this.layer.events.on({
+                "beforefeaturesadded": this.cacheFeatures,
+                scope: this
+            });
+        }
+        return activated;
+    },
+    
+    /**
+     * APIMethod: deactivate
+     * Deactivate the strategy.  Unregister any listeners, do appropriate
+     *     tear-down.
+     * 
+     * Returns:
+     * {Boolean} The strategy was successfully deactivated.
+     */
+    deactivate: function() {
+        var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this);
+        if(deactivated) {
+            this.clearCache();
+            this.layer.events.un({
+                "beforefeaturesadded": this.cacheFeatures,
+                scope: this
+            });
+        }
+        return deactivated;
+    },
+    
+    /**
+     * Method: cacheFeatures
+     * Cache features before they are added to the layer.
+     *
+     * Parameters:
+     * event - {Object} The event that this was listening for.  This will come
+     *     with a batch of features to be paged.
+     */
+    cacheFeatures: function(event) {
+        if(!this.paging) {
+            this.clearCache();
+            this.features = event.features;
+            this.pageNext(event);
+        }
+    },
+    
+    /**
+     * Method: clearCache
+     * Clear out the cached features.  This destroys features, assuming
+     *     nothing else has a reference.
+     */
+    clearCache: function() {
+        if(this.features) {
+            for(var i=0; i<this.features.length; ++i) {
+                this.features[i].destroy();
+            }
+        }
+        this.features = null;
+        this.num = null;
+    },
+    
+    /**
+     * APIMethod: pageCount
+     * Get the total count of pages given the current cache of features.
+     *
+     * Returns:
+     * {Integer} The page count.
+     */
+    pageCount: function() {
+        var numFeatures = this.features ? this.features.length : 0;
+        return Math.ceil(numFeatures / this.length);
+    },
+
+    /**
+     * APIMethod: pageNum
+     * Get the zero based page number.
+     *
+     * Returns:
+     * {Integer} The current page number being displayed.
+     */
+    pageNum: function() {
+        return this.num;
+    },
+
+    /**
+     * APIMethod: pageLength
+     * Gets or sets page length.
+     *
+     * Parameters:
+     * newLength: {Integer} Optional length to be set.
+     *
+     * Returns:
+     * {Integer} The length of a page (number of features per page).
+     */
+    pageLength: function(newLength) {
+        if(newLength && newLength > 0) {
+            this.length = newLength;
+        }
+        return this.length;
+    },
+
+    /**
+     * APIMethod: pageNext
+     * Display the next page of features.
+     *
+     * Returns:
+     * {Boolean} A new page was displayed.
+     */
+    pageNext: function(event) {
+        var changed = false;
+        if(this.features) {
+            if(this.num === null) {
+                this.num = -1;
+            }
+            var start = (this.num + 1) * this.length;
+            changed = this.page(start, event);
+        }
+        return changed;
+    },
+
+    /**
+     * APIMethod: pagePrevious
+     * Display the previous page of features.
+     *
+     * Returns:
+     * {Boolean} A new page was displayed.
+     */
+    pagePrevious: function() {
+        var changed = false;
+        if(this.features) {
+            if(this.num === null) {
+                this.num = this.pageCount();
+            }
+            var start = (this.num - 1) * this.length;
+            changed = this.page(start);
+        }
+        return changed;
+    },
+    
+    /**
+     * Method: page
+     * Display the page starting at the given index from the cache.
+     *
+     * Returns:
+     * {Boolean} A new page was displayed.
+     */
+    page: function(start, event) {
+        var changed = false;
+        if(this.features) {
+            if(start >= 0 && start < this.features.length) {
+                var num = Math.floor(start / this.length);
+                if(num != this.num) {
+                    this.paging = true;
+                    var features = this.features.slice(start, start + this.length);
+                    this.layer.removeFeatures(this.layer.features);
+                    this.num = num;
+                    // modify the event if any
+                    if(event && event.features) {
+                        // this.was called by an event listener
+                        event.features = features;
+                    } else {
+                        // this was called directly on the strategy
+                        this.layer.addFeatures(features);
+                    }
+                    this.paging = false;
+                    changed = true;
+                }
+            }
+        }
+        return changed;
+    },
+    
+    CLASS_NAME: "OpenLayers.Strategy.Paging" 
+});
diff --git a/lib/OpenLayers/Util.js b/lib/OpenLayers/Util.js
index 0eac4b4a5e..4bf8045ef8 100644
--- a/lib/OpenLayers/Util.js
+++ b/lib/OpenLayers/Util.js
@@ -796,13 +796,18 @@ OpenLayers.Util.rad = function(x) {return x*Math.PI/180;};
 
 /**
  * Function: distVincenty
+ * Given two objects representing points with geographic coordinates, this
+ *     calculates the distance between those points on the surface of an
+ *     ellipsoid.
  * 
  * Parameters:
  * p1 - {<OpenLayers.LonLat>} (or any object with both .lat, .lon properties)
  * p2 - {<OpenLayers.LonLat>} (or any object with both .lat, .lon properties)
  * 
  * Returns:
- * {Float}
+ * {Float} The distance (in km) between the two input points as measured on an
+ *     ellipsoid.  Note that the input point objects must be in geographic
+ *     coordinates (decimal degrees) and the return distance is in kilometers.
  */
 OpenLayers.Util.distVincenty=function(p1, p2) {
     var a = 6378137, b = 6356752.3142,  f = 1/298.257223563;
diff --git a/tests/Control/Permalink.html b/tests/Control/Permalink.html
index b811987a64..c42d2039d2 100644
--- a/tests/Control/Permalink.html
+++ b/tests/Control/Permalink.html
@@ -134,6 +134,99 @@
         t.eq(this.map.controls[this.map.controls.length-1].CLASS_NAME, "CustomArgParser", "Custom ArgParser added correctly.");
         t.eq(control.div.firstChild.getAttribute("href"), "./edit.html?zoom=2&lat=0&lon=1.75781&layers=B&customParam=foo", "Custom parameter encoded correctly.");
     }
+    
+    function test_Control_Permalink_createParams(t) {
+        t.plan(18);
+
+        var baseLayer = { 'isBaseLayer': true };
+
+        var m = {
+            'getCenter': function() { return null; }
+        };
+        
+        var pl = {
+            'map': m,
+            'base': {}
+        };
+
+        old_getParameters = OpenLayers.Util.getParameters;
+        OpenLayers.Util.getParameters = function(base) {
+            t.ok(base == pl.base, "correct base sent in to Util.getParameters()");
+            return g_Params;
+        };
+        
+      //null center, null map.getCenter()
+        g_Params = {};
+        m.baseLayer = baseLayer;
+        var returnParams = OpenLayers.Control.Permalink.prototype.createParams.apply(pl, []);
+        t.ok(returnParams == g_Params, "correct params returned on null center");
+
+      //valid center, zoom, layers
+        g_Params = { 'test': {} };
+        var center = { 'lon': 1.2345678901, 'lat': 9.8765432109 };
+        var zoom = {};
+        var layers = [
+            { 'isBaseLayer': true },
+            baseLayer,
+            { 'isBaseLayer': false, 'getVisibility': function() { return true; } },
+            { 'isBaseLayer': false, 'getVisibility': function() { return false; } }
+        ];
+        var returnParams = OpenLayers.Control.Permalink.prototype.createParams.apply(pl, [center, zoom, layers]);
+
+        t.ok(returnParams.test == g_Params.test, "correct params returned from Util.getParameters() when valid center, zoom, layers");
+        t.ok(returnParams.zoom == zoom, "params.zoom set correctly when valid center, zoom, layers");
+        t.eq(returnParams.lon, 1.23457, "lon set and rounded correctly when valid center, zoom, layers");
+        t.eq(returnParams.lat, 9.87654, "lat set and rounded correctly when valid center, zoom, layers");
+        t.eq(returnParams.layers, "0BTF", "layers processed correctly when valid center, zoom, layers")
+
+
+      //null center, zoom, layers, with displayProjection
+        g_Params = { 'test': {} };
+        g_Projection = {};
+        m = {
+            'baseLayer': baseLayer,
+            'getProjectionObject':  function() { return g_Projection; },
+            'center': { 'lon': {}, 'lat': {} },
+            'getCenter': function() { return this.center; },
+            'zoom': {},
+            'getZoom': function() { return this.zoom; },
+           'layers': [
+                { 'isBaseLayer': false, 'getVisibility': function() { return true; } },
+                baseLayer,
+                { 'isBaseLayer': false, 'getVisibility': function() { return false; } },
+                { 'isBaseLayer': true }
+            ],
+            'getLayers': function() { return this.layers; }
+        };
+        pl = { 
+            'base': {},
+            'map': m,
+            'displayProjection': {}
+        };
+        
+        old_transform = OpenLayers.Projection.transform;
+        OpenLayers.Projection.transform = function(point, projObj, dispProj) {
+            t.ok(point.x = m.center.lon, "correct x value passed into transform");
+            t.ok(point.y = m.center.lat, "correct x value passed into transform");
+            t.ok(projObj == g_Projection, "correct projection object from map passed into transform");
+            t.ok(dispProj == pl.displayProjection, "correct displayProjection from control passed into transform");
+
+            return { 'x': 9.8765432109, 'y': 1.2345678901 };
+        };
+        
+        center = zoom = layers = null;
+
+        var returnParams = OpenLayers.Control.Permalink.prototype.createParams.apply(pl, [center, zoom, layers]);
+        t.ok(returnParams.test == g_Params.test, "correct params returned from Util.getParameters() when null center, zoom, layers, with displayProjection");
+        t.ok(returnParams.zoom == m.zoom, "params.zoom set correctly when null center, zoom, layers, with displayProjection");
+        t.eq(returnParams.lon, 9.87654, "lon set, transformed, and rounded correctly when null center, zoom, layers, with displayProjection");
+        t.eq(returnParams.lat, 1.23457, "lat set, transformed, and rounded correctly when null center, zoom, layers, with displayProjection");
+        t.eq(returnParams.layers, "TBF0", "layers processed correctly when null center, zoom, layers, with displayProjection");
+
+        OpenLayers.Util.getParameters = old_getParameters;
+        OpenLayers.Projection.transform = old_transform;
+    }
+    
   </script>
 </head>
 <body>
diff --git a/tests/Format.html b/tests/Format.html
index 70a1d5fe6a..9c761dff28 100644
--- a/tests/Format.html
+++ b/tests/Format.html
@@ -4,7 +4,7 @@
   <script type="text/javascript">
 
     function test_Format_constructor(t) {
-        t.plan(4);
+        t.plan(5);
     
         var options = {'foo': 'bar'};
         var format = new OpenLayers.Format(options);
@@ -13,6 +13,7 @@
         t.eq(format.foo, "bar", "constructor sets options correctly");
         t.eq(typeof format.read, "function", "format has a read function");
         t.eq(typeof format.write, "function", "format has a write function");
+        t.eq(format.options, options, "format.options correctly set");
     }
 
   </script>
diff --git a/tests/Format/GML/cases.js b/tests/Format/GML/cases.js
new file mode 100644
index 0000000000..214e84fd71
--- /dev/null
+++ b/tests/Format/GML/cases.js
@@ -0,0 +1,222 @@
+var xml = new OpenLayers.Format.XML(); 
+function readXML(file) {
+    return xml.read(document.getElementById(file).firstChild.nodeValue);
+}
+
+var cases = {
+
+    "v2/point-coord.xml": new OpenLayers.Geometry.Point(1, 2),
+
+    "v2/point-coordinates.xml": new OpenLayers.Geometry.Point(1, 2),
+
+    "v2/linestring-coord.xml": new OpenLayers.Geometry.LineString([
+        new OpenLayers.Geometry.Point(1, 2),
+        new OpenLayers.Geometry.Point(3, 4)
+    ]),
+    
+    "v2/linestring-coordinates.xml": new OpenLayers.Geometry.LineString([
+        new OpenLayers.Geometry.Point(1, 2),
+        new OpenLayers.Geometry.Point(3, 4)
+    ]),
+    
+    "v2/linearring-coord.xml": new OpenLayers.Geometry.LinearRing([
+        new OpenLayers.Geometry.Point(1, 2),
+        new OpenLayers.Geometry.Point(3, 4),
+        new OpenLayers.Geometry.Point(5, 6),
+        new OpenLayers.Geometry.Point(1, 2)
+    ]),
+    
+    "v2/linearring-coordinates.xml": new OpenLayers.Geometry.LinearRing([
+        new OpenLayers.Geometry.Point(1, 2),
+        new OpenLayers.Geometry.Point(3, 4),
+        new OpenLayers.Geometry.Point(5, 6),
+        new OpenLayers.Geometry.Point(1, 2)
+    ]),
+    
+    "v2/polygon-coord.xml": new OpenLayers.Geometry.Polygon([
+        new OpenLayers.Geometry.LinearRing([
+            new OpenLayers.Geometry.Point(1, 2),
+            new OpenLayers.Geometry.Point(3, 4),
+            new OpenLayers.Geometry.Point(5, 6),
+            new OpenLayers.Geometry.Point(1, 2)
+        ]),
+        new OpenLayers.Geometry.LinearRing([
+            new OpenLayers.Geometry.Point(2, 3),
+            new OpenLayers.Geometry.Point(4, 5),
+            new OpenLayers.Geometry.Point(6, 7),
+            new OpenLayers.Geometry.Point(2, 3)
+        ]),
+        new OpenLayers.Geometry.LinearRing([
+            new OpenLayers.Geometry.Point(3, 4),
+            new OpenLayers.Geometry.Point(5, 6),
+            new OpenLayers.Geometry.Point(7, 8),
+            new OpenLayers.Geometry.Point(3, 4)
+        ])
+    ]),
+    
+    "v2/polygon-coordinates.xml": new OpenLayers.Geometry.Polygon([
+        new OpenLayers.Geometry.LinearRing([
+            new OpenLayers.Geometry.Point(1, 2),
+            new OpenLayers.Geometry.Point(3, 4),
+            new OpenLayers.Geometry.Point(5, 6),
+            new OpenLayers.Geometry.Point(1, 2)
+        ]),
+        new OpenLayers.Geometry.LinearRing([
+            new OpenLayers.Geometry.Point(2, 3),
+            new OpenLayers.Geometry.Point(4, 5),
+            new OpenLayers.Geometry.Point(6, 7),
+            new OpenLayers.Geometry.Point(2, 3)
+        ]),
+        new OpenLayers.Geometry.LinearRing([
+            new OpenLayers.Geometry.Point(3, 4),
+            new OpenLayers.Geometry.Point(5, 6),
+            new OpenLayers.Geometry.Point(7, 8),
+            new OpenLayers.Geometry.Point(3, 4)
+        ])
+    ]),
+    
+    "v2/multipoint-coord.xml": new OpenLayers.Geometry.MultiPoint([
+        new OpenLayers.Geometry.Point(1, 2),
+        new OpenLayers.Geometry.Point(2, 3),
+        new OpenLayers.Geometry.Point(3, 4)
+    ]),
+    
+    "v2/multipoint-coordinates.xml": new OpenLayers.Geometry.MultiPoint([
+        new OpenLayers.Geometry.Point(1, 2),
+        new OpenLayers.Geometry.Point(2, 3),
+        new OpenLayers.Geometry.Point(3, 4)
+    ]),
+    
+    "v2/multilinestring-coord.xml": new OpenLayers.Geometry.MultiLineString([
+        new OpenLayers.Geometry.LineString([
+            new OpenLayers.Geometry.Point(1, 2),
+            new OpenLayers.Geometry.Point(2, 3)
+        ]),
+        new OpenLayers.Geometry.LineString([
+            new OpenLayers.Geometry.Point(3, 4),
+            new OpenLayers.Geometry.Point(4, 5)
+        ])
+    ]),
+    
+    "v2/multilinestring-coordinates.xml": new OpenLayers.Geometry.MultiLineString([
+        new OpenLayers.Geometry.LineString([
+            new OpenLayers.Geometry.Point(1, 2),
+            new OpenLayers.Geometry.Point(2, 3)
+        ]),
+        new OpenLayers.Geometry.LineString([
+            new OpenLayers.Geometry.Point(3, 4),
+            new OpenLayers.Geometry.Point(4, 5)
+        ])
+    ]),
+    
+    "v2/multipolygon-coord.xml": new OpenLayers.Geometry.MultiPolygon([
+        new OpenLayers.Geometry.Polygon([
+            new OpenLayers.Geometry.LinearRing([
+                new OpenLayers.Geometry.Point(1, 2),
+                new OpenLayers.Geometry.Point(3, 4),
+                new OpenLayers.Geometry.Point(5, 6),
+                new OpenLayers.Geometry.Point(1, 2)
+            ]),
+            new OpenLayers.Geometry.LinearRing([
+                new OpenLayers.Geometry.Point(2, 3),
+                new OpenLayers.Geometry.Point(4, 5),
+                new OpenLayers.Geometry.Point(6, 7),
+                new OpenLayers.Geometry.Point(2, 3)
+            ]),
+            new OpenLayers.Geometry.LinearRing([
+                new OpenLayers.Geometry.Point(3, 4),
+                new OpenLayers.Geometry.Point(5, 6),
+                new OpenLayers.Geometry.Point(7, 8),
+                new OpenLayers.Geometry.Point(3, 4)
+            ])
+        ]),
+        new OpenLayers.Geometry.Polygon([
+            new OpenLayers.Geometry.LinearRing([
+                new OpenLayers.Geometry.Point(1, 2),
+                new OpenLayers.Geometry.Point(3, 4),
+                new OpenLayers.Geometry.Point(5, 6),
+                new OpenLayers.Geometry.Point(1, 2)
+            ])
+        ])
+    ]),
+    
+    "v2/multipolygon-coordinates.xml": new OpenLayers.Geometry.MultiPolygon([
+        new OpenLayers.Geometry.Polygon([
+            new OpenLayers.Geometry.LinearRing([
+                new OpenLayers.Geometry.Point(1, 2),
+                new OpenLayers.Geometry.Point(3, 4),
+                new OpenLayers.Geometry.Point(5, 6),
+                new OpenLayers.Geometry.Point(1, 2)
+            ]),
+            new OpenLayers.Geometry.LinearRing([
+                new OpenLayers.Geometry.Point(2, 3),
+                new OpenLayers.Geometry.Point(4, 5),
+                new OpenLayers.Geometry.Point(6, 7),
+                new OpenLayers.Geometry.Point(2, 3)
+            ]),
+            new OpenLayers.Geometry.LinearRing([
+                new OpenLayers.Geometry.Point(3, 4),
+                new OpenLayers.Geometry.Point(5, 6),
+                new OpenLayers.Geometry.Point(7, 8),
+                new OpenLayers.Geometry.Point(3, 4)
+            ])
+        ]),
+        new OpenLayers.Geometry.Polygon([
+            new OpenLayers.Geometry.LinearRing([
+                new OpenLayers.Geometry.Point(1, 2),
+                new OpenLayers.Geometry.Point(3, 4),
+                new OpenLayers.Geometry.Point(5, 6),
+                new OpenLayers.Geometry.Point(1, 2)
+            ])
+        ])
+    ]),
+    
+    "v2/geometrycollection-coordinates.xml": new OpenLayers.Geometry.Collection([
+        new OpenLayers.Geometry.Point(1, 2),
+        new OpenLayers.Geometry.LineString([
+            new OpenLayers.Geometry.Point(1, 2),
+            new OpenLayers.Geometry.Point(3, 4)
+        ]),
+        new OpenLayers.Geometry.Polygon([
+            new OpenLayers.Geometry.LinearRing([
+                new OpenLayers.Geometry.Point(1, 2),
+                new OpenLayers.Geometry.Point(3, 4),
+                new OpenLayers.Geometry.Point(5, 6),
+                new OpenLayers.Geometry.Point(1, 2)
+            ]),
+            new OpenLayers.Geometry.LinearRing([
+                new OpenLayers.Geometry.Point(2, 3),
+                new OpenLayers.Geometry.Point(4, 5),
+                new OpenLayers.Geometry.Point(6, 7),
+                new OpenLayers.Geometry.Point(2, 3)
+            ]),
+            new OpenLayers.Geometry.LinearRing([
+                new OpenLayers.Geometry.Point(3, 4),
+                new OpenLayers.Geometry.Point(5, 6),
+                new OpenLayers.Geometry.Point(7, 8),
+                new OpenLayers.Geometry.Point(3, 4)
+            ])
+        ])
+    ]),
+
+    "v2/box-coord.xml": new OpenLayers.Bounds(1, 2, 3, 4),
+    
+    "v2/box-coordinates.xml": new OpenLayers.Bounds(1, 2, 3, 4)
+    
+};
+
+// cases for v3 use the same geometries
+OpenLayers.Util.extend(cases, {
+    "v3/point.xml": cases["v2/point-coordinates.xml"],
+    "v3/linestring.xml": cases["v2/linestring-coordinates.xml"],
+    "v3/polygon.xml": cases["v2/polygon-coordinates.xml"],
+    "v3/multipoint-singular.xml": cases["v2/multipoint-coordinates.xml"],
+    "v3/multipoint-plural.xml": cases["v2/multipoint-coordinates.xml"],
+    "v3/multilinestring-singular.xml": cases["v2/multilinestring-coordinates.xml"],
+    "v3/multilinestring-plural.xml": cases["v2/multilinestring-coordinates.xml"],
+    "v3/multipolygon-singular.xml": cases["v2/multipolygon-coordinates.xml"],
+    "v3/multipolygon-plural.xml": cases["v2/multipolygon-coordinates.xml"],
+    "v3/multisurface-singular.xml": cases["v2/multipolygon-coordinates.xml"],
+    "v3/multisurface-plural.xml": cases["v2/multipolygon-coordinates.xml"],
+    "v3/envelope.xml": cases["v2/box-coordinates.xml"]
+});
\ No newline at end of file
diff --git a/tests/Format/GML/v2.html b/tests/Format/GML/v2.html
new file mode 100644
index 0000000000..6684883ab8
--- /dev/null
+++ b/tests/Format/GML/v2.html
@@ -0,0 +1,605 @@
+<?xml version="1.0" encoding="utf-8"?>
+<html xmlns="http://www.w3.org/1999/xhtml"> 
+<head> 
+    <script src="../../../lib/OpenLayers.js"></script>
+    <script src="cases.js"></script>
+    <script type="text/javascript">
+
+    function test_readNode_geometry(t) {
+        var files = [
+            "v2/point-coord.xml", "v2/point-coordinates.xml",
+            "v2/linestring-coord.xml", "v2/linestring-coordinates.xml",
+            "v2/polygon-coord.xml", "v2/polygon-coordinates.xml",
+            "v2/multipoint-coord.xml", "v2/multipoint-coordinates.xml",
+            "v2/multilinestring-coord.xml", "v2/multilinestring-coordinates.xml",
+            "v2/multipolygon-coord.xml", "v2/multipolygon-coordinates.xml",
+            "v2/geometrycollection-coordinates.xml"
+        ];
+
+        var len = files.length;
+        t.plan(len);
+
+        var format = new OpenLayers.Format.GML.v2({
+            featureType: "feature",
+            featureNS: "http://example.com/feature"
+        });
+        var file, doc, expect, out;
+        for(var i=0; i<len; ++i) {
+            file = files[i];
+            expect = cases[file];
+            if(expect) {
+                doc = readXML(file);
+                if(doc && doc.documentElement) {
+                    out = format.readNode(doc.documentElement);
+                    if(out.components && out.components.length == 1) {
+                        t.geom_eq(out.components[0], expect, "[" + file + "] geometry read");
+                    } else {
+                        t.fail("[" + file + "] gml parsing");
+                    }
+                } else {
+                    t.fail("[" + file + "] xml parsing");
+                }
+            } else {
+                t.fail("[" + file + "] case not found");
+            }
+        }
+        
+    }
+    
+    function test_readNode_bounds(t) {
+        var files = ["v2/box-coord.xml", "v2/box-coordinates.xml"];
+
+        var len = files.length;
+        t.plan(len);
+        
+        var file, doc, expect, got;
+        var format = new OpenLayers.Format.GML.v2({
+            featureType: "feature",
+            featureNS: "http://example.com/feature"
+        });
+        for(var i=0; i<len; ++i) {
+            file = files[i];
+            expect = cases[file];
+            if(expect) {
+                doc = readXML(file);
+                if(doc && doc.documentElement) {
+                    out = format.readNode(doc.documentElement);
+                    if(out.components && out.components.length == 1) {
+                        got = out.components[0];
+                        if(got instanceof OpenLayers.Bounds) {
+                            t.ok(out.components[0].equals(expect), "[" + file + "] bounds read")
+                        } else {
+                            t.fail("[" + file + "] expected a bounds, got " + got);
+                        }
+                    } else {
+                        t.fail("[" + file + "] gml parsing");
+                    }
+                } else {
+                    t.fail("[" + file + "] xml parsing");
+                }
+            } else {
+                t.fail("[" + file + "] case not found");
+            }
+        }
+        
+    }
+    
+    function test_writeNode_geometry(t) {
+        // we only care to write the 'coordinates' variant of GML 2
+        var files = [
+            "v2/point-coordinates.xml",
+            "v2/linestring-coordinates.xml",
+            "v2/polygon-coordinates.xml",
+            "v2/multipoint-coordinates.xml",
+            "v2/multilinestring-coordinates.xml",
+            "v2/multipolygon-coordinates.xml",
+            "v2/geometrycollection-coordinates.xml"
+        ];
+
+        var len = files.length;
+        t.plan(len);
+
+        var format = new OpenLayers.Format.GML.v2({
+            featureType: "feature",
+            featureNS: "http://example.com/feature",
+            srsName: "foo" // GML geometry collections require srsName, we only write if provided
+        });
+        var file, geom, doc, node;
+        for(var i=0; i<len; ++i) {
+            file = files[i];
+            geom = cases[file];
+            if(geom) {
+                doc = readXML(file);
+                if(doc && doc.documentElement) {
+                    node = format.writeNode("feature:_geometry", geom);
+                    t.xml_eq(node.firstChild, doc.documentElement, "[" + file + "] geometry written");
+                } else {
+                    t.fail("[" + file + "] xml parsing");
+                }
+            } else {
+                t.fail("[" + file + "] case not found");
+            }
+        }
+    }
+
+    function test_writeNode_bounds(t) {
+        // we only care to write the 'coordinates' variant of GML 2
+        var files = [
+            "v2/box-coordinates.xml"
+        ];
+
+        var len = files.length;
+        t.plan(len);
+
+        var format = new OpenLayers.Format.GML.v2({
+            featureType: "feature",
+            featureNS: "http://example.com/feature",
+            srsName: "foo" // GML box does not require srsName, we only write if provided
+        });
+        var file, bounds, doc, node;
+        for(var i=0; i<len; ++i) {
+            file = files[i];
+            bounds = cases[file];
+            if(bounds) {
+                doc = readXML(file);
+                if(doc && doc.documentElement) {
+                    node = format.writeNode("gml:Box", bounds);
+                    t.xml_eq(node, doc.documentElement, "[" + file + "] bounds written");
+                } else {
+                    t.fail("[" + file + "] xml parsing");
+                }
+            } else {
+                t.fail("[" + file + "] case not found");
+            }
+        }
+    }
+    
+    function test_read(t) {
+        t.plan(8);
+        var doc = readXML("v2/topp-states.xml");
+        var format = new OpenLayers.Format.GML.v2({
+            featureType: "states",
+            featureNS: "http://www.openplans.org/topp",
+            geometryName: "the_geom"
+        });
+        var features = format.read(doc.documentElement);
+        
+        t.eq(features.length, 3, "read 3 features");
+        var feature = features[0];
+        t.eq(feature.fid, "states.1", "read fid");
+        t.eq(feature.geometry.CLASS_NAME, "OpenLayers.Geometry.MultiPolygon",
+             "read multipolygon geometry");
+        var attributes = feature.attributes;
+        t.eq(attributes["STATE_NAME"], "Illinois", "read STATE_NAME");
+        t.eq(attributes["STATE_FIPS"], "17", "read STATE_FIPS");
+        t.eq(attributes["SUB_REGION"], "E N Cen", "read SUB_REGION");
+        t.eq(attributes["STATE_ABBR"], "IL", "read STATE_ABBR");
+        t.eq(attributes["LAND_KM"], "143986.61", "read LAND_KM");
+    }
+    
+    function test_write(t) {
+        t.plan(1);
+        var doc = readXML("v2/topp-states.xml");
+        var format = new OpenLayers.Format.GML.v2({
+            featureType: "states",
+            featureNS: "http://www.openplans.org/topp",
+            geometryName: "the_geom",
+            schemaLocation: "http://www.openplans.org/topp http://sigma.openplans.org:80/geoserver/wfs?service=WFS&version=1.0.0&request=DescribeFeatureType&typeName=topp:states http://www.opengis.net/wfs http://sigma.openplans.org:80/geoserver/schemas/wfs/1.0.0/WFS-basic.xsd",
+            srsName: "http://www.opengis.net/gml/srs/epsg.xml#4326"
+        });
+        var features = format.read(doc.documentElement);
+        
+        var got = format.write(features);
+        t.xml_eq(got, doc.documentElement, "wfs:FeatureCollection round trip");
+        
+    }
+
+   </script>
+</head>
+<body>
+<div id="v2/point-coord.xml"><!--
+<gml:Point xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+  <gml:coord>
+    <gml:X>1</gml:X>
+    <gml:Y>2</gml:Y>
+  </gml:coord>
+</gml:Point>
+--></div>
+<div id="v2/point-coordinates.xml"><!--
+<gml:Point xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+  <gml:coordinates decimal="." cs="," ts=" ">1,2</gml:coordinates>
+</gml:Point>
+--></div>
+<div id="v2/linestring-coord.xml"><!--
+<gml:LineString xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+  <gml:coord>
+    <gml:X>1</gml:X>
+    <gml:Y>2</gml:Y>
+  </gml:coord>
+  <gml:coord>
+    <gml:X>3</gml:X>
+    <gml:Y>4</gml:Y>
+  </gml:coord>
+</gml:LineString>
+--></div>
+<div id="v2/linestring-coordinates.xml"><!--
+<gml:LineString xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+  <gml:coordinates decimal="." cs="," ts=" ">1,2 3,4</gml:coordinates>
+</gml:LineString>
+--></div>
+<div id="v2/polygon-coord.xml"><!--
+<gml:Polygon xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:outerBoundaryIs>
+        <gml:LinearRing>
+            <gml:coord>
+                <gml:X>1</gml:X>
+                <gml:Y>2</gml:Y>
+            </gml:coord>
+            <gml:coord>
+                <gml:X>3</gml:X>
+                <gml:Y>4</gml:Y>
+            </gml:coord>
+            <gml:coord>
+                <gml:X>5</gml:X>
+                <gml:Y>6</gml:Y>
+            </gml:coord>
+            <gml:coord>
+                <gml:X>1</gml:X>
+                <gml:Y>2</gml:Y>
+            </gml:coord>
+        </gml:LinearRing>
+    </gml:outerBoundaryIs>
+    <gml:innerBoundaryIs>
+        <gml:LinearRing>
+            <gml:coord>
+                <gml:X>2</gml:X>
+                <gml:Y>3</gml:Y>
+            </gml:coord>
+            <gml:coord>
+                <gml:X>4</gml:X>
+                <gml:Y>5</gml:Y>
+            </gml:coord>
+            <gml:coord>
+                <gml:X>6</gml:X>
+                <gml:Y>7</gml:Y>
+            </gml:coord>
+            <gml:coord>
+                <gml:X>2</gml:X>
+                <gml:Y>3</gml:Y>
+            </gml:coord>
+        </gml:LinearRing>
+    </gml:innerBoundaryIs>    
+    <gml:innerBoundaryIs>
+        <gml:LinearRing>
+            <gml:coord>
+                <gml:X>3</gml:X>
+                <gml:Y>4</gml:Y>
+            </gml:coord>
+            <gml:coord>
+                <gml:X>5</gml:X>
+                <gml:Y>6</gml:Y>
+            </gml:coord>
+            <gml:coord>
+                <gml:X>7</gml:X>
+                <gml:Y>8</gml:Y>
+            </gml:coord>
+            <gml:coord>
+                <gml:X>3</gml:X>
+                <gml:Y>4</gml:Y>
+            </gml:coord>
+        </gml:LinearRing>
+    </gml:innerBoundaryIs>    
+</gml:Polygon>
+--></div>
+<div id="v2/polygon-coordinates.xml"><!--
+<gml:Polygon xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:outerBoundaryIs>
+        <gml:LinearRing>
+            <gml:coordinates decimal="." cs="," ts=" ">1,2 3,4 5,6 1,2</gml:coordinates>
+        </gml:LinearRing>
+    </gml:outerBoundaryIs>
+    <gml:innerBoundaryIs>
+        <gml:LinearRing>
+            <gml:coordinates decimal="." cs="," ts=" ">2,3 4,5 6,7 2,3</gml:coordinates>
+        </gml:LinearRing>
+    </gml:innerBoundaryIs>    
+    <gml:innerBoundaryIs>
+        <gml:LinearRing>
+            <gml:coordinates decimal="." cs="," ts=" ">3,4 5,6 7,8 3,4</gml:coordinates>
+        </gml:LinearRing>
+    </gml:innerBoundaryIs>    
+</gml:Polygon>
+--></div>
+<div id="v2/multipoint-coord.xml"><!--
+<gml:MultiPoint xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:pointMember>
+        <gml:Point>
+            <gml:coord>
+                <gml:X>1</gml:X>
+                <gml:Y>2</gml:Y>
+            </gml:coord>
+        </gml:Point>
+    </gml:pointMember>
+    <gml:pointMember>
+        <gml:Point>
+            <gml:coord>
+                <gml:X>2</gml:X>
+                <gml:Y>3</gml:Y>
+            </gml:coord>
+        </gml:Point>
+    </gml:pointMember>
+    <gml:pointMember>
+        <gml:Point>
+            <gml:coord>
+                <gml:X>3</gml:X>
+                <gml:Y>4</gml:Y>
+            </gml:coord>
+        </gml:Point>
+    </gml:pointMember>
+</gml:MultiPoint>
+--></div>
+<div id="v2/multipoint-coordinates.xml"><!--
+<gml:MultiPoint xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:pointMember>
+        <gml:Point>
+            <gml:coordinates decimal="." cs="," ts=" ">1,2</gml:coordinates>
+        </gml:Point>
+    </gml:pointMember>
+    <gml:pointMember>
+        <gml:Point>
+            <gml:coordinates decimal="." cs="," ts=" ">2,3</gml:coordinates>
+        </gml:Point>
+    </gml:pointMember>
+    <gml:pointMember>
+        <gml:Point>
+            <gml:coordinates decimal="." cs="," ts=" ">3,4</gml:coordinates>
+        </gml:Point>
+    </gml:pointMember>
+</gml:MultiPoint>
+--></div>
+<div id="v2/multilinestring-coord.xml"><!--
+<gml:MultiLineString xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:lineStringMember>
+        <gml:LineString>
+            <gml:coord>
+                <gml:X>1</gml:X>
+                <gml:Y>2</gml:Y>
+            </gml:coord>
+            <gml:coord>
+                <gml:X>2</gml:X>
+                <gml:Y>3</gml:Y>
+            </gml:coord>
+        </gml:LineString>
+    </gml:lineStringMember>
+    <gml:lineStringMember>
+        <gml:LineString>
+            <gml:coord>
+                <gml:X>3</gml:X>
+                <gml:Y>4</gml:Y>
+            </gml:coord>
+            <gml:coord>
+                <gml:X>4</gml:X>
+                <gml:Y>5</gml:Y>
+            </gml:coord>
+        </gml:LineString>
+    </gml:lineStringMember>
+</gml:MultiLineString>
+--></div>
+<div id="v2/multilinestring-coordinates.xml"><!--
+<gml:MultiLineString xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:lineStringMember>
+        <gml:LineString>
+            <gml:coordinates decimal="." cs="," ts=" ">1,2 2,3</gml:coordinates>
+        </gml:LineString>
+    </gml:lineStringMember>
+    <gml:lineStringMember>
+        <gml:LineString>
+            <gml:coordinates decimal="." cs="," ts=" ">3,4 4,5</gml:coordinates>
+        </gml:LineString>
+    </gml:lineStringMember>
+</gml:MultiLineString>
+--></div>
+<div id="v2/multipolygon-coord.xml"><!--
+<gml:MultiPolygon xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:polygonMember>
+        <gml:Polygon>
+            <gml:outerBoundaryIs>
+                <gml:LinearRing>
+                    <gml:coord>
+                        <gml:X>1</gml:X>
+                        <gml:Y>2</gml:Y>
+                    </gml:coord>
+                    <gml:coord>
+                        <gml:X>3</gml:X>
+                        <gml:Y>4</gml:Y>
+                    </gml:coord>
+                    <gml:coord>
+                        <gml:X>5</gml:X>
+                        <gml:Y>6</gml:Y>
+                    </gml:coord>
+                    <gml:coord>
+                        <gml:X>1</gml:X>
+                        <gml:Y>2</gml:Y>
+                    </gml:coord>
+                </gml:LinearRing>
+            </gml:outerBoundaryIs>
+            <gml:innerBoundaryIs>
+                <gml:LinearRing>
+                    <gml:coord>
+                        <gml:X>2</gml:X>
+                        <gml:Y>3</gml:Y>
+                    </gml:coord>
+                    <gml:coord>
+                        <gml:X>4</gml:X>
+                        <gml:Y>5</gml:Y>
+                    </gml:coord>
+                    <gml:coord>
+                        <gml:X>6</gml:X>
+                        <gml:Y>7</gml:Y>
+                    </gml:coord>
+                    <gml:coord>
+                        <gml:X>2</gml:X>
+                        <gml:Y>3</gml:Y>
+                    </gml:coord>
+                </gml:LinearRing>
+            </gml:innerBoundaryIs>    
+            <gml:innerBoundaryIs>
+                <gml:LinearRing>
+                    <gml:coord>
+                        <gml:X>3</gml:X>
+                        <gml:Y>4</gml:Y>
+                    </gml:coord>
+                    <gml:coord>
+                        <gml:X>5</gml:X>
+                        <gml:Y>6</gml:Y>
+                    </gml:coord>
+                    <gml:coord>
+                        <gml:X>7</gml:X>
+                        <gml:Y>8</gml:Y>
+                    </gml:coord>
+                    <gml:coord>
+                        <gml:X>3</gml:X>
+                        <gml:Y>4</gml:Y>
+                    </gml:coord>
+                </gml:LinearRing>
+            </gml:innerBoundaryIs>    
+        </gml:Polygon>
+    </gml:polygonMember>
+    <gml:polygonMember>
+        <gml:Polygon>
+            <gml:outerBoundaryIs>
+                <gml:LinearRing>
+                    <gml:coord>
+                        <gml:X>1</gml:X>
+                        <gml:Y>2</gml:Y>
+                    </gml:coord>
+                    <gml:coord>
+                        <gml:X>3</gml:X>
+                        <gml:Y>4</gml:Y>
+                    </gml:coord>
+                    <gml:coord>
+                        <gml:X>5</gml:X>
+                        <gml:Y>6</gml:Y>
+                    </gml:coord>
+                    <gml:coord>
+                        <gml:X>1</gml:X>
+                        <gml:Y>2</gml:Y>
+                    </gml:coord>
+                </gml:LinearRing>
+            </gml:outerBoundaryIs>
+        </gml:Polygon>
+    </gml:polygonMember>
+</gml:MultiPolygon>
+--></div>
+<div id="v2/multipolygon-coordinates.xml"><!--
+<gml:MultiPolygon xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:polygonMember>
+        <gml:Polygon>
+            <gml:outerBoundaryIs>
+                <gml:LinearRing>
+                    <gml:coordinates decimal="." cs="," ts=" ">1,2 3,4 5,6 1,2</gml:coordinates>
+                </gml:LinearRing>
+            </gml:outerBoundaryIs>
+            <gml:innerBoundaryIs>
+                <gml:LinearRing>
+                    <gml:coordinates decimal="." cs="," ts=" ">2,3 4,5 6,7 2,3</gml:coordinates>
+                </gml:LinearRing>
+            </gml:innerBoundaryIs>    
+            <gml:innerBoundaryIs>
+                <gml:LinearRing>
+                    <gml:coordinates decimal="." cs="," ts=" ">3,4 5,6 7,8 3,4</gml:coordinates>
+                </gml:LinearRing>
+            </gml:innerBoundaryIs>    
+        </gml:Polygon>
+    </gml:polygonMember>
+    <gml:polygonMember>
+        <gml:Polygon>
+            <gml:outerBoundaryIs>
+                <gml:LinearRing>
+                    <gml:coordinates decimal="." cs="," ts=" ">1,2 3,4 5,6 1,2</gml:coordinates>
+                </gml:LinearRing>
+            </gml:outerBoundaryIs>
+        </gml:Polygon>
+    </gml:polygonMember>
+</gml:MultiPolygon>
+--></div>
+<div id="v2/geometrycollection-coordinates.xml"><!--
+<gml:GeometryCollection xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:geometryMember>
+        <gml:Point srsName="foo">
+          <gml:coordinates decimal="." cs="," ts=" ">1,2</gml:coordinates>
+        </gml:Point>
+    </gml:geometryMember>
+    <gml:geometryMember>
+        <gml:LineString srsName="foo">
+          <gml:coordinates decimal="." cs="," ts=" ">1,2 3,4</gml:coordinates>
+        </gml:LineString>
+    </gml:geometryMember>
+    <gml:geometryMember>
+        <gml:Polygon srsName="foo">
+            <gml:outerBoundaryIs>
+                <gml:LinearRing>
+                    <gml:coordinates decimal="." cs="," ts=" ">1,2 3,4 5,6 1,2</gml:coordinates>
+                </gml:LinearRing>
+            </gml:outerBoundaryIs>
+            <gml:innerBoundaryIs>
+                <gml:LinearRing>
+                    <gml:coordinates decimal="." cs="," ts=" ">2,3 4,5 6,7 2,3</gml:coordinates>
+                </gml:LinearRing>
+            </gml:innerBoundaryIs>    
+            <gml:innerBoundaryIs>
+                <gml:LinearRing>
+                    <gml:coordinates decimal="." cs="," ts=" ">3,4 5,6 7,8 3,4</gml:coordinates>
+                </gml:LinearRing>
+            </gml:innerBoundaryIs>    
+        </gml:Polygon>
+    </gml:geometryMember>
+</gml:GeometryCollection>
+--></div>
+<div id="v2/box-coord.xml"><!--
+<gml:Box xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+  <gml:coord>
+    <gml:X>1</gml:X>
+    <gml:Y>2</gml:Y>
+  </gml:coord>
+  <gml:coord>
+    <gml:X>3</gml:X>
+    <gml:Y>4</gml:Y>
+  </gml:coord>
+</gml:Box>
+--></div>
+<div id="v2/box-coordinates.xml"><!--
+<gml:Box xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+  <gml:coordinates decimal="." cs="," ts=" ">1,2 3,4</gml:coordinates>
+</gml:Box>
+--></div>
+<div id="v2/linearring-coord.xml"><!--
+<gml:LinearRing xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:coord>
+        <gml:X>1</gml:X>
+        <gml:Y>2</gml:Y>
+    </gml:coord>
+    <gml:coord>
+        <gml:X>3</gml:X>
+        <gml:Y>4</gml:Y>
+    </gml:coord>
+    <gml:coord>
+        <gml:X>5</gml:X>
+        <gml:Y>6</gml:Y>
+    </gml:coord>
+    <gml:coord>
+        <gml:X>1</gml:X>
+        <gml:Y>2</gml:Y>
+    </gml:coord>
+</gml:LinearRing>
+--></div>
+<div id="v2/linearring-coordinates.xml"><!--
+<gml:LinearRing xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+  <gml:coordinates decimal="." cs="," ts=" ">1,2 3,4 5,6 1,2</gml:coordinates>
+</gml:LinearRing>
+--></div>
+<div id="v2/topp-states.xml"><!--
+<?xml version="1.0" encoding="UTF-8"?><wfs:FeatureCollection xmlns="http://www.opengis.net/wfs" xmlns:wfs="http://www.opengis.net/wfs" xmlns:topp="http://www.openplans.org/topp" xmlns:gml="http://www.opengis.net/gml" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.openplans.org/topp http://sigma.openplans.org:80/geoserver/wfs?service=WFS&amp;version=1.0.0&amp;request=DescribeFeatureType&amp;typeName=topp:states http://www.opengis.net/wfs http://sigma.openplans.org:80/geoserver/schemas/wfs/1.0.0/WFS-basic.xsd"><gml:featureMember><topp:states fid="states.1"><topp:the_geom><gml:MultiPolygon srsName="http://www.opengis.net/gml/srs/epsg.xml#4326"><gml:polygonMember><gml:Polygon><gml:outerBoundaryIs><gml:LinearRing><gml:coordinates xmlns:gml="http://www.opengis.net/gml" decimal="." cs="," ts=" ">37.51099,-88.071564 37.476273,-88.087883 37.442852,-88.311707 37.409309,-88.359177 37.420292,-88.419853 37.400757,-88.467644 37.296852,-88.511322 37.257782,-88.501427 37.205669,-88.450699 37.15691,-88.422516 37.098671,-88.45047 37.072144,-88.476799 37.06818,-88.4907 37.06477,-88.517273 37.072815,-88.559273 37.109047,-88.61422 37.13541,-88.68837 37.141182,-88.739113 37.152107,-88.746506 37.202194,-88.863289 37.218407,-88.932503 37.220036,-88.993172 37.18586,-89.065033 37.112137,-89.116821 37.093185,-89.146347 37.064236,-89.169548 37.025711,-89.174332 36.99844,-89.150246 36.988113,-89.12986 36.986771,-89.193512 37.028973,-89.210052 37.041733,-89.237679 37.087124,-89.264053 37.091244,-89.284233 37.085384,-89.303291 37.060909,-89.3097 37.027733,-89.264244 37.008686,-89.262001 36.999207,-89.282768 37.009682,-89.310982 37.049213,-89.38295 37.099083,-89.37999 37.137203,-89.423798 37.165318,-89.440521 37.224266,-89.468216 37.253731,-89.465309 37.256001,-89.489594 37.276402,-89.513885 37.304962,-89.513885 37.329441,-89.50058 37.339409,-89.468742 37.355717,-89.435738 37.411018,-89.427574 37.453186,-89.453621 37.491726,-89.494781 37.571957,-89.524971 37.615929,-89.513367 37.650375,-89.51918 37.67984,-89.513374 37.694798,-89.521523 37.706104,-89.581436 37.745453,-89.666458 37.78397,-89.675858 37.804794,-89.691055 37.840992,-89.728447 37.905064,-89.851715 37.905487,-89.861046 37.891876,-89.866814 37.875904,-89.900551 37.878044,-89.937874 37.911884,-89.978912 37.963634,-89.958229 37.969318,-90.010811 37.993206,-90.041924 38.032272,-90.119339 38.053951,-90.134712 38.088905,-90.207527 38.122169,-90.254059 38.166817,-90.289635 38.188713,-90.336716 38.234299,-90.364769 38.323559,-90.369347 38.36533,-90.358688 38.390846,-90.339607 38.427357,-90.301842 38.518688,-90.265785 38.532768,-90.26123 38.562805,-90.240944 38.610271,-90.183708 38.658772,-90.183578 38.700363,-90.20224 38.723965,-90.196571 38.773098,-90.163399 38.785484,-90.135178 38.80051,-90.121727 38.830467,-90.113121 38.853031,-90.132812 38.914509,-90.243927 38.924717,-90.278931 38.924908,-90.31974 38.96233,-90.413071 38.959179,-90.469841 38.891609,-90.530426 38.871326,-90.570328 38.880795,-90.627213 38.935253,-90.668877 39.037792,-90.70607 39.058178,-90.707588 39.0937,-90.690399 39.144211,-90.716736 39.195873,-90.718193 39.224747,-90.732338 39.24781,-90.738083 39.296803,-90.779343 39.350452,-90.850494 39.400585,-90.947891 39.444412,-91.036339 39.473984,-91.064384 39.528927,-91.093613 39.552593,-91.156189 39.600021,-91.203247 39.685917,-91.317665 39.72464,-91.367088 39.761272,-91.373421 39.803772,-91.381714 39.863049,-91.449188 39.885242,-91.450989 39.901829,-91.434052 39.921837,-91.430389 39.946064,-91.447243 40.005753,-91.487289 40.066711,-91.504005 40.134544,-91.516129 40.200459,-91.506546 40.251377,-91.498932 40.309624,-91.486694 40.371902,-91.448593 40.386875,-91.418816 40.392361,-91.385757 40.402988,-91.372757 40.44725,-91.385399 40.503654,-91.374794 40.528496,-91.382103 40.547993,-91.412872 40.572971,-91.411118 40.603439,-91.37561 40.639545,-91.262062 40.643818,-91.214912 40.656311,-91.162498 40.682148,-91.129158 40.705402,-91.119987 40.761547,-91.092751 40.833729,-91.088905 40.879585,-91.04921 40.923927,-90.983276 40.950504,-90.960709 41.070362,-90.954651 41.104359,-90.957787 41.144371,-90.990341 41.165825,-91.018257 41.176258,-91.05632 41.231522,-91.101524 41.267818,-91.102348 41.334896,-91.07328 41.401379,-91.055786 41.423508,-91.027489 41.431084,-91.000694 41.421234,-90.949654 41.444622,-90.844139 41.449821,-90.7799 41.450062,-90.708214 41.462318,-90.658791 41.509586,-90.6007 41.52597,-90.54084 41.527546,-90.454994 41.543579,-90.434967 41.567272,-90.423004 41.586849,-90.348366 41.602798,-90.339348 41.64909,-90.341133 41.722736,-90.326027 41.756466,-90.304886 41.781738,-90.25531 41.806137,-90.195839 41.930775,-90.154518 41.983963,-90.14267 42.033428,-90.150536 42.061043,-90.168098 42.103745,-90.166649 42.120502,-90.176086 42.122688,-90.191574 42.159721,-90.230934 42.197319,-90.323601 42.210209,-90.367729 42.242645,-90.407173 42.263924,-90.417984 42.340633,-90.427681 42.360073,-90.441597 42.388783,-90.491043 42.421837,-90.563583 42.46056,-90.605827 42.475643,-90.648346 42.494698,-90.651772 42.509361,-90.638329 42.508362,-90.419975 42.504108,-89.923569 42.50346,-89.834618 42.49749,-89.400497 42.497906,-89.359444 42.490864,-88.939079 42.490906,-88.764954 42.489655,-88.70652 42.49197,-88.297897 42.489613,-88.194702 42.489132,-87.79731 42.314213,-87.836945 42.156456,-87.760239 42.059822,-87.670547 41.847332,-87.612625 41.723591,-87.529861 41.469715,-87.532646 41.301304,-87.532448 41.173756,-87.531731 41.00993,-87.532021 40.745411,-87.532669 40.49461,-87.53717 40.483246,-87.535675 40.166195,-87.535339 39.887302,-87.535774 39.609341,-87.535576 39.477448,-87.538567 39.350525,-87.540215 39.338268,-87.597664 39.307404,-87.625237 39.297661,-87.610619 39.281418,-87.615799 39.258163,-87.606895 39.248753,-87.584564 39.208466,-87.588593 39.198128,-87.594208 39.196068,-87.607925 39.168507,-87.644257 39.146679,-87.670326 39.130653,-87.659454 39.113468,-87.662262 39.103943,-87.631668 39.088974,-87.630867 39.084606,-87.612007 39.062435,-87.58532 38.995743,-87.581749 38.994083,-87.591858 38.977077,-87.547905 38.963703,-87.53347 38.931919,-87.530182 38.904861,-87.5392 38.869812,-87.559059 38.857891,-87.550507 38.795559,-87.507889 38.776699,-87.519028 38.769722,-87.508003 38.736633,-87.508316 38.685974,-87.543892 38.672169,-87.588478 38.642811,-87.625191 38.622917,-87.628647 38.599209,-87.619827 38.593178,-87.640594 38.573872,-87.652855 38.547424,-87.672943 38.515369,-87.65139 38.500443,-87.653534 38.504005,-87.679909 38.481533,-87.692818 38.466125,-87.756096 38.457096,-87.758659 38.44548,-87.738953 38.417965,-87.748428 38.378124,-87.784019 38.352524,-87.834503 38.286098,-87.850082 38.285362,-87.863007 38.316788,-87.874039 38.315552,-87.883446 38.300659,-87.888466 38.281048,-87.914108 38.302345,-87.913651 38.304771,-87.925919 38.241085,-87.980019 38.234814,-87.986008 38.200714,-87.977928 38.171131,-87.932289 38.157528,-87.931992 38.136913,-87.950569 38.13176,-87.973503 38.103302,-88.018547 38.092346,-88.012329 38.096748,-87.964867 38.073307,-87.975296 38.054085,-88.034729 38.04512,-88.043091 38.038303,-88.041473 38.033531,-88.021698 38.008236,-88.029213 37.975056,-88.021706 37.956264,-88.042511 37.934498,-88.041771 37.929783,-88.064621 37.944,-88.078941 37.92366,-88.084 37.917591,-88.030441 37.905758,-88.026588 37.896004,-88.044868 37.90617,-88.100082 37.895306,-88.101456 37.867809,-88.075737 37.843746,-88.034241 37.827522,-88.042137 37.831249,-88.089264 37.817612,-88.086029 37.805683,-88.035576 37.735401,-88.072472 37.700745,-88.133636 37.660686,-88.15937 37.628479,-88.157631 37.583572,-88.134171 37.51099,-88.071564</gml:coordinates></gml:LinearRing></gml:outerBoundaryIs></gml:Polygon></gml:polygonMember></gml:MultiPolygon></topp:the_geom><topp:STATE_NAME>Illinois</topp:STATE_NAME><topp:STATE_FIPS>17</topp:STATE_FIPS><topp:SUB_REGION>E N Cen</topp:SUB_REGION><topp:STATE_ABBR>IL</topp:STATE_ABBR><topp:LAND_KM>143986.61</topp:LAND_KM><topp:WATER_KM>1993.335</topp:WATER_KM><topp:PERSONS>1.1430602E7</topp:PERSONS><topp:FAMILIES>2924880.0</topp:FAMILIES><topp:HOUSHOLD>4202240.0</topp:HOUSHOLD><topp:MALE>5552233.0</topp:MALE><topp:FEMALE>5878369.0</topp:FEMALE><topp:WORKERS>4199206.0</topp:WORKERS><topp:DRVALONE>3741715.0</topp:DRVALONE><topp:CARPOOL>652603.0</topp:CARPOOL><topp:PUBTRANS>538071.0</topp:PUBTRANS><topp:EMPLOYED>5417967.0</topp:EMPLOYED><topp:UNEMPLOY>385040.0</topp:UNEMPLOY><topp:SERVICE>1360159.0</topp:SERVICE><topp:MANUAL>828906.0</topp:MANUAL><topp:P_MALE>0.486</topp:P_MALE><topp:P_FEMALE>0.514</topp:P_FEMALE><topp:SAMP_POP>1747776.0</topp:SAMP_POP></topp:states></gml:featureMember><gml:featureMember><topp:states fid="states.2"><topp:the_geom><gml:MultiPolygon srsName="http://www.opengis.net/gml/srs/epsg.xml#4326"><gml:polygonMember><gml:Polygon><gml:outerBoundaryIs><gml:LinearRing><gml:coordinates xmlns:gml="http://www.opengis.net/gml" decimal="." cs="," ts=" ">38.966557,-77.008232 38.889988,-76.911209 38.78812,-77.045448 38.813915,-77.035248 38.829365,-77.045189 38.838413,-77.040405 38.862431,-77.039078 38.886101,-77.067886 38.9156,-77.078949 38.93206,-77.122627 38.993431,-77.042389 38.966557,-77.008232</gml:coordinates></gml:LinearRing></gml:outerBoundaryIs></gml:Polygon></gml:polygonMember></gml:MultiPolygon></topp:the_geom><topp:STATE_NAME>District of Columbia</topp:STATE_NAME><topp:STATE_FIPS>11</topp:STATE_FIPS><topp:SUB_REGION>S Atl</topp:SUB_REGION><topp:STATE_ABBR>DC</topp:STATE_ABBR><topp:LAND_KM>159.055</topp:LAND_KM><topp:WATER_KM>17.991</topp:WATER_KM><topp:PERSONS>606900.0</topp:PERSONS><topp:FAMILIES>122087.0</topp:FAMILIES><topp:HOUSHOLD>249634.0</topp:HOUSHOLD><topp:MALE>282970.0</topp:MALE><topp:FEMALE>323930.0</topp:FEMALE><topp:WORKERS>229975.0</topp:WORKERS><topp:DRVALONE>106694.0</topp:DRVALONE><topp:CARPOOL>36621.0</topp:CARPOOL><topp:PUBTRANS>111422.0</topp:PUBTRANS><topp:EMPLOYED>303994.0</topp:EMPLOYED><topp:UNEMPLOY>23442.0</topp:UNEMPLOY><topp:SERVICE>65498.0</topp:SERVICE><topp:MANUAL>22407.0</topp:MANUAL><topp:P_MALE>0.466</topp:P_MALE><topp:P_FEMALE>0.534</topp:P_FEMALE><topp:SAMP_POP>72696.0</topp:SAMP_POP></topp:states></gml:featureMember><gml:featureMember><topp:states fid="states.3"><topp:the_geom><gml:MultiPolygon srsName="http://www.opengis.net/gml/srs/epsg.xml#4326"><gml:polygonMember><gml:Polygon><gml:outerBoundaryIs><gml:LinearRing><gml:coordinates xmlns:gml="http://www.opengis.net/gml" decimal="." cs="," ts=" ">38.557476,-75.70742 38.649551,-75.71106 38.83017,-75.724937 39.141548,-75.752922 39.247753,-75.761658 39.295849,-75.764664 39.383007,-75.772697 39.723755,-75.791435 39.724442,-75.775269 39.774818,-75.745934 39.820347,-75.695114 39.838196,-75.644341 39.840008,-75.583794 39.826435,-75.470345 39.79887,-75.42083 39.789658,-75.412117 39.77813,-75.428009 39.763248,-75.460754 39.741718,-75.475128 39.719971,-75.476334 39.714745,-75.489639 39.612793,-75.610725 39.566723,-75.562996 39.463768,-75.590187 39.36694,-75.515572 39.257637,-75.402481 39.073036,-75.397728 39.012386,-75.324852 38.945911,-75.307899 38.80867,-75.190941 38.799812,-75.083138 38.44949,-75.045998 38.449963,-75.068298 38.450451,-75.093094 38.455208,-75.350204 38.463066,-75.69915 38.557476,-75.70742</gml:coordinates></gml:LinearRing></gml:outerBoundaryIs></gml:Polygon></gml:polygonMember></gml:MultiPolygon></topp:the_geom><topp:STATE_NAME>Delaware</topp:STATE_NAME><topp:STATE_FIPS>10</topp:STATE_FIPS><topp:SUB_REGION>S Atl</topp:SUB_REGION><topp:STATE_ABBR>DE</topp:STATE_ABBR><topp:LAND_KM>5062.456</topp:LAND_KM><topp:WATER_KM>1385.022</topp:WATER_KM><topp:PERSONS>666168.0</topp:PERSONS><topp:FAMILIES>175867.0</topp:FAMILIES><topp:HOUSHOLD>247497.0</topp:HOUSHOLD><topp:MALE>322968.0</topp:MALE><topp:FEMALE>343200.0</topp:FEMALE><topp:WORKERS>247566.0</topp:WORKERS><topp:DRVALONE>258087.0</topp:DRVALONE><topp:CARPOOL>42968.0</topp:CARPOOL><topp:PUBTRANS>8069.0</topp:PUBTRANS><topp:EMPLOYED>335147.0</topp:EMPLOYED><topp:UNEMPLOY>13945.0</topp:UNEMPLOY><topp:SERVICE>87973.0</topp:SERVICE><topp:MANUAL>44140.0</topp:MANUAL><topp:P_MALE>0.485</topp:P_MALE><topp:P_FEMALE>0.515</topp:P_FEMALE><topp:SAMP_POP>102776.0</topp:SAMP_POP></topp:states></gml:featureMember></wfs:FeatureCollection>
+--></div>
+</body>
+</html>
diff --git a/tests/Format/GML/v3.html b/tests/Format/GML/v3.html
new file mode 100644
index 0000000000..e24a2fb0a8
--- /dev/null
+++ b/tests/Format/GML/v3.html
@@ -0,0 +1,551 @@
+<html> 
+<head> 
+    <script src="../../../lib/OpenLayers.js"></script>
+    <script src="cases.js"></script>
+    <script type="text/javascript">
+
+    function test_readNode_geometry(t) {
+        var files = [
+            "v2/point-coord.xml", "v2/point-coordinates.xml",
+            "v2/linestring-coord.xml", "v2/linestring-coordinates.xml",
+            "v2/multipoint-coord.xml", "v2/multipoint-coordinates.xml",
+            "v2/multilinestring-coord.xml", "v2/multilinestring-coordinates.xml",
+            "v3/point.xml", "v3/linestring.xml", "v3/polygon.xml",
+            "v3/multipoint-singular.xml", "v3/multipoint-plural.xml",
+            "v3/multilinestring-singular.xml", "v3/multilinestring-plural.xml",
+            "v3/multipolygon-singular.xml", "v3/multipolygon-plural.xml",
+            "v3/multisurface-singular.xml", "v3/multisurface-plural.xml"
+        ];
+
+        var len = files.length;
+        t.plan(len);
+
+        var format = new OpenLayers.Format.GML.v3({
+            featureType: "feature",
+            featureNS: "http://example.com/feature"
+        });
+        var file, doc, expect, out;
+        for(var i=0; i<len; ++i) {
+            file = files[i];
+            expect = cases[file];
+            if(expect) {
+                doc = readXML(file);
+                if(doc && doc.documentElement) {
+                    out = format.readNode(doc.documentElement);
+                    if(out.components && out.components.length == 1) {
+                        t.geom_eq(out.components[0], expect, "[" + file + "] geometry read");
+                    } else {
+                        t.fail("[" + file + "] gml parsing");
+                    }
+                } else {
+                    t.fail("[" + file + "] xml parsing");
+                }
+            } else {
+                t.fail("[" + file + "] case not found");
+            }
+        }
+        
+    }
+
+    function test_readNode_bounds(t) {
+        var files = ["v3/envelope.xml"];
+
+        var len = files.length;
+        t.plan(len);
+        
+        var file, doc, expect, got;
+        var format = new OpenLayers.Format.GML.v3({
+            featureType: "feature",
+            featureNS: "http://example.com/feature"
+        });
+        for(var i=0; i<len; ++i) {
+            file = files[i];
+            expect = cases[file];
+            if(expect) {
+                doc = readXML(file);
+                if(doc && doc.documentElement) {
+                    out = format.readNode(doc.documentElement);
+                    if(out.components && out.components.length == 1) {
+                        got = out.components[0];
+                        if(got instanceof OpenLayers.Bounds) {
+                            t.ok(out.components[0].equals(expect), "[" + file + "] bounds read")
+                        } else {
+                            t.fail("[" + file + "] expected a bounds, got " + got);
+                        }
+                    } else {
+                        t.fail("[" + file + "] gml parsing");
+                    }
+                } else {
+                    t.fail("[" + file + "] xml parsing");
+                }
+            } else {
+                t.fail("[" + file + "] case not found");
+            }
+        }
+        
+    }
+
+    function test_writeNode_geometry(t) {
+        // we only care to write the 'pos' and 'posList' variants of GML 3 - conforming with simple features profile
+        var files = [
+            "v3/point.xml",
+            "v3/linestring.xml",
+            "v3/polygon.xml",
+            "v3/multipoint-singular.xml",
+            "v3/multilinestring-singular.xml",
+            "v3/multipolygon-singular.xml"
+        ];
+
+        var len = files.length;
+        t.plan(len);
+
+        var format = new OpenLayers.Format.GML.v3({
+            featureType: "feature",
+            featureNS: "http://example.com/feature",
+            srsName: "foo" // GML geometry collections require srsName, we only write if provided
+        });
+        var file, geom, doc, node;
+        for(var i=0; i<len; ++i) {
+            file = files[i];
+            geom = cases[file];
+            if(geom) {
+                doc = readXML(file);
+                if(doc && doc.documentElement) {
+                    node = format.writeNode("feature:_geometry", geom);
+                    t.xml_eq(node.firstChild, doc.documentElement, "[" + file + "] geometry written");
+                } else {
+                    t.fail("[" + file + "] xml parsing");
+                }
+            } else {
+                t.fail("[" + file + "] case not found");
+            }
+        }
+    }
+
+    function test_writeNode_bounds(t) {
+        // we only care to write the 'coordinates' variant of GML 2
+        var files = [
+            "v3/envelope.xml"
+        ];
+
+        var len = files.length;
+        t.plan(len);
+
+        var format = new OpenLayers.Format.GML.v3({
+            featureType: "feature",
+            featureNS: "http://example.com/feature",
+            srsName: "foo" // GML envelopes require srsName, we only write if provided
+        });
+        var file, bounds, doc, node;
+        for(var i=0; i<len; ++i) {
+            file = files[i];
+            bounds = cases[file];
+            if(bounds) {
+                doc = readXML(file);
+                if(doc && doc.documentElement) {
+                    node = format.writeNode("gml:Envelope", bounds);
+                    t.xml_eq(node, doc.documentElement, "[" + file + "] bounds written");
+                } else {
+                    t.fail("[" + file + "] xml parsing");
+                }
+            } else {
+                t.fail("[" + file + "] case not found");
+            }
+        }
+    }
+
+    function test_read(t) {
+        t.plan(8);
+        var doc = readXML("v3/topp-states-wfs.xml");
+        var format = new OpenLayers.Format.GML.v3({
+            featureType: "states",
+            featureNS: "http://www.openplans.org/topp",
+            geometryName: "the_geom"
+        });
+        var features = format.read(doc.documentElement);
+        
+        t.eq(features.length, 3, "read 3 features");
+        var feature = features[0];
+        t.eq(feature.fid, "states.1", "read fid");
+        t.eq(feature.geometry.CLASS_NAME, "OpenLayers.Geometry.MultiPolygon",
+             "read multipolygon geometry");
+        var attributes = feature.attributes;
+        t.eq(attributes["STATE_NAME"], "Illinois", "read STATE_NAME");
+        t.eq(attributes["STATE_FIPS"], "17", "read STATE_FIPS");
+        t.eq(attributes["SUB_REGION"], "E N Cen", "read SUB_REGION");
+        t.eq(attributes["STATE_ABBR"], "IL", "read STATE_ABBR");
+        t.eq(attributes["LAND_KM"], "143986.61", "read LAND_KM");
+    }
+
+    function test_write(t) {
+        t.plan(1);
+        var doc = readXML("v3/topp-states-gml.xml");
+        var format = new OpenLayers.Format.GML.v3({
+            featureType: "states",
+            featureNS: "http://www.openplans.org/topp",
+            geometryName: "the_geom",
+            srsName: "urn:x-ogc:def:crs:EPSG:4326",
+            schemaLocation: "http://www.openplans.org/topp http://sigma.openplans.org:80/geoserver/wfs?service=WFS&version=1.1.0&request=DescribeFeatureType&typeName=topp:states http://www.opengis.net/gml http://schemas.opengis.net/gml/3.2.1/gml.xsd"
+        });
+        var features = format.read(doc.documentElement);
+        
+        var got = format.write(features);
+        t.xml_eq(got, doc.documentElement, "gml:featureMembers round trip");
+    }
+
+   </script>
+</head>
+<body>
+<div id="v3/envelope.xml"><!--
+<gml:Envelope xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:lowerCorner><gml:pos>1 2</gml:pos></gml:lowerCorner>
+    <gml:upperCorner><gml:pos>3 4</gml:pos></gml:upperCorner>
+</gml:Envelope>
+--></div>
+<div id="v3/linearring.xml"><!--
+<gml:LinearRing xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:posList>1 2 3 4 5 6 1 2</gml:posList>
+</gml:LinearRing>
+--></div>
+<div id="v3/linestring.xml"><!--
+<gml:LineString xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+  <gml:posList>1 2 3 4</gml:posList>
+</gml:LineString>
+--></div>
+<div id="v3/multilinestring-plural.xml"><!--
+<gml:MultiLineString xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:lineStringMembers>
+        <gml:LineString>
+            <gml:posList>1 2 2 3</gml:posList>
+        </gml:LineString>
+        <gml:LineString>
+            <gml:posList>3 4 4 5</gml:posList>
+        </gml:LineString>
+    </gml:lineStringMembers>
+</gml:MultiLineString>
+--></div>
+<div id="v3/multilinestring-singular.xml"><!--
+<gml:MultiLineString xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:lineStringMember>
+        <gml:LineString>
+            <gml:posList>1 2 2 3</gml:posList>
+        </gml:LineString>
+    </gml:lineStringMember>
+    <gml:lineStringMember>
+        <gml:LineString>
+            <gml:posList>3 4 4 5</gml:posList>
+        </gml:LineString>
+    </gml:lineStringMember>
+</gml:MultiLineString>
+--></div>
+<div id="v3/multipoint-plural.xml"><!--
+<gml:MultiPoint xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:pointMembers>
+        <gml:Point>
+            <gml:pos>1 2</gml:pos>
+        </gml:Point>
+        <gml:Point>
+            <gml:pos>2 3</gml:pos>
+        </gml:Point>
+        <gml:Point>
+            <gml:pos>3 4</gml:pos>
+        </gml:Point>
+    </gml:pointMembers>
+</gml:MultiPoint>
+--></div>
+<div id="v3/multipoint-singular.xml"><!--
+<gml:MultiPoint xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:pointMember>
+        <gml:Point>
+            <gml:pos>1 2</gml:pos>
+        </gml:Point>
+    </gml:pointMember>
+    <gml:pointMember>
+        <gml:Point>
+            <gml:pos>2 3</gml:pos>
+        </gml:Point>
+    </gml:pointMember>
+    <gml:pointMember>
+        <gml:Point>
+            <gml:pos>3 4</gml:pos>
+        </gml:Point>
+    </gml:pointMember>
+</gml:MultiPoint>
+--></div>
+<div id="v3/multipolygon-plural.xml"><!--
+<gml:MultiPolygon xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:polygonMembers>
+        <gml:Polygon>
+            <gml:exterior>
+                <gml:LinearRing>
+                    <gml:posList>1 2 3 4 5 6 1 2</gml:posList>
+                </gml:LinearRing>
+            </gml:exterior>
+            <gml:interior>
+                <gml:LinearRing>
+                    <gml:posList>2 3 4 5 6 7 2 3</gml:posList>
+                </gml:LinearRing>
+            </gml:interior>    
+            <gml:interior>
+                <gml:LinearRing>
+                    <gml:posList>3 4 5 6 7 8 3 4</gml:posList>
+                </gml:LinearRing>
+            </gml:interior>
+        </gml:Polygon>
+        <gml:Polygon>
+            <gml:exterior>
+                <gml:LinearRing>
+                    <gml:posList>1 2 3 4 5 6 1 2</gml:posList>
+                </gml:LinearRing>
+            </gml:exterior>
+        </gml:Polygon>
+    </gml:polygonMembers>
+</gml:MultiPolygon>
+--></div>
+<div id="v3/multipolygon-singular.xml"><!--
+<gml:MultiPolygon xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:polygonMember>
+        <gml:Polygon>
+            <gml:exterior>
+                <gml:LinearRing>
+                    <gml:posList>1 2 3 4 5 6 1 2</gml:posList>
+                </gml:LinearRing>
+            </gml:exterior>
+            <gml:interior>
+                <gml:LinearRing>
+                    <gml:posList>2 3 4 5 6 7 2 3</gml:posList>
+                </gml:LinearRing>
+            </gml:interior>    
+            <gml:interior>
+                <gml:LinearRing>
+                    <gml:posList>3 4 5 6 7 8 3 4</gml:posList>
+                </gml:LinearRing>
+            </gml:interior>
+        </gml:Polygon>
+    </gml:polygonMember>
+    <gml:polygonMember>
+        <gml:Polygon>
+            <gml:exterior>
+                <gml:LinearRing>
+                    <gml:posList>1 2 3 4 5 6 1 2</gml:posList>
+                </gml:LinearRing>
+            </gml:exterior>
+        </gml:Polygon>
+    </gml:polygonMember>
+</gml:MultiPolygon>
+--></div>
+<div id="v3/multisurface-plural.xml"><!--
+<gml:MultiSurface xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:surfaceMembers>
+        <gml:Polygon>
+            <gml:exterior>
+                <gml:LinearRing>
+                    <gml:posList>1 2 3 4 5 6 1 2</gml:posList>
+                </gml:LinearRing>
+            </gml:exterior>
+            <gml:interior>
+                <gml:LinearRing>
+                    <gml:posList>2 3 4 5 6 7 2 3</gml:posList>
+                </gml:LinearRing>
+            </gml:interior>    
+            <gml:interior>
+                <gml:LinearRing>
+                    <gml:posList>3 4 5 6 7 8 3 4</gml:posList>
+                </gml:LinearRing>
+            </gml:interior>
+        </gml:Polygon>
+        <gml:Polygon>
+            <gml:exterior>
+                <gml:LinearRing>
+                    <gml:posList>1 2 3 4 5 6 1 2</gml:posList>
+                </gml:LinearRing>
+            </gml:exterior>
+        </gml:Polygon>
+    </gml:surfaceMembers>
+</gml:MultiSurface>
+--></div>
+<div id="v3/multisurface-singular.xml"><!--
+<gml:MultiSurface xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:surfaceMember>
+        <gml:Polygon>
+            <gml:exterior>
+                <gml:LinearRing>
+                    <gml:posList>1 2 3 4 5 6 1 2</gml:posList>
+                </gml:LinearRing>
+            </gml:exterior>
+            <gml:interior>
+                <gml:LinearRing>
+                    <gml:posList>2 3 4 5 6 7 2 3</gml:posList>
+                </gml:LinearRing>
+            </gml:interior>    
+            <gml:interior>
+                <gml:LinearRing>
+                    <gml:posList>3 4 5 6 7 8 3 4</gml:posList>
+                </gml:LinearRing>
+            </gml:interior>
+        </gml:Polygon>
+    </gml:surfaceMember>
+    <gml:surfaceMember>
+        <gml:Polygon>
+            <gml:exterior>
+                <gml:LinearRing>
+                    <gml:posList>1 2 3 4 5 6 1 2</gml:posList>
+                </gml:LinearRing>
+            </gml:exterior>
+        </gml:Polygon>
+    </gml:surfaceMember>
+</gml:MultiSurface>
+--></div>
+<div id="v3/point.xml"><!--
+<gml:Point xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+  <gml:pos>1 2</gml:pos>
+</gml:Point>
+--></div>
+<div id="v3/polygon.xml"><!--
+<gml:Polygon xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:exterior>
+        <gml:LinearRing>
+            <gml:posList>1 2 3 4 5 6 1 2</gml:posList>
+        </gml:LinearRing>
+    </gml:exterior>
+    <gml:interior>
+        <gml:LinearRing>
+            <gml:posList>2 3 4 5 6 7 2 3</gml:posList>
+        </gml:LinearRing>
+    </gml:interior>    
+    <gml:interior>
+        <gml:LinearRing>
+            <gml:posList>3 4 5 6 7 8 3 4</gml:posList>
+        </gml:LinearRing>
+    </gml:interior>    
+</gml:Polygon>
+--></div>
+<div id="v3/topp-states-gml.xml"><!--
+<?xml version="1.0" encoding="UTF-8"?>
+<gml:featureMembers xsi:schemaLocation="http://www.openplans.org/topp http://sigma.openplans.org:80/geoserver/wfs?service=WFS&amp;version=1.1.0&amp;request=DescribeFeatureType&amp;typeName=topp:states http://www.opengis.net/gml http://schemas.opengis.net/gml/3.2.1/gml.xsd" xmlns:topp="http://www.openplans.org/topp" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:gml="http://www.opengis.net/gml"><topp:states fid="states.1"><topp:the_geom><gml:MultiPolygon srsName="urn:x-ogc:def:crs:EPSG:4326"><gml:polygonMember><gml:Polygon><gml:exterior><gml:LinearRing><gml:posList>37.511 -88.071 37.476 -88.087 37.442 -88.311 37.409 -88.359 37.421 -88.419 37.401 -88.467 37.296 -88.511 37.257 -88.501 37.205 -88.451 37.156 -88.422 37.098 -88.451 37.072 -88.476 37.068 -88.491 37.064 -88.517 37.072 -88.559 37.109 -88.614 37.135 -88.688 37.141 -88.739 37.152 -88.746 37.202 -88.863 37.218 -88.932 37.221 -88.993 37.185 -89.065 37.112 -89.116 37.093 -89.146 37.064 -89.169 37.025 -89.174 36.998 -89.151 36.988 -89.129 36.986 -89.193 37.028 -89.211 37.041 -89.237 37.087 -89.264 37.091 -89.284 37.085 -89.303 37.061 -89.309 37.027 -89.264 37.008 -89.262 36.999 -89.282 37.009 -89.311 37.049 -89.382 37.099 -89.379 37.137 -89.423 37.165 -89.441 37.224 -89.468 37.253 -89.465 37.256 -89.489 37.276 -89.513 37.304 -89.513 37.329 -89.501 37.339 -89.468 37.355 -89.435 37.411 -89.427 37.453 -89.453 37.491 -89.494 37.571 -89.524 37.615 -89.513 37.651 -89.519 37.679 -89.513 37.694 -89.521 37.706 -89.581 37.745 -89.666 37.783 -89.675 37.804 -89.691 37.841 -89.728 37.905 -89.851 37.905 -89.861 37.891 -89.866 37.875 -89.901 37.878 -89.937 37.911 -89.978 37.963 -89.958 37.969 -90.011 37.993 -90.041 38.032 -90.119 38.053 -90.134 38.088 -90.207 38.122 -90.254 38.166 -90.289 38.188 -90.336 38.234 -90.364 38.323 -90.369 38.365 -90.358 38.391 -90.339 38.427 -90.301 38.518 -90.265 38.532 -90.261 38.562 -90.241 38.611 -90.183 38.658 -90.183 38.701 -90.202 38.723 -90.196 38.773 -90.163 38.785 -90.135 38.801 -90.121 38.831 -90.113 38.853 -90.132 38.914 -90.243 38.924 -90.278 38.924 -90.319 38.962 -90.413 38.959 -90.469 38.891 -90.531 38.871 -90.571 38.881 -90.627 38.935 -90.668 39.037 -90.706 39.058 -90.707 39.093 -90.691 39.144 -90.716 39.195 -90.718 39.224 -90.732 39.247 -90.738 39.296 -90.779 39.351 -90.851 39.401 -90.947 39.444 -91.036 39.473 -91.064 39.528 -91.093 39.552 -91.156 39.601 -91.203 39.685 -91.317 39.724 -91.367 39.761 -91.373 39.803 -91.381 39.863 -91.449 39.885 -91.451 39.901 -91.434 39.921 -91.431 39.946 -91.447 40.005 -91.487 40.066 -91.504 40.134 -91.516 40.201 -91.506 40.251 -91.498 40.309 -91.486 40.371 -91.448 40.386 -91.418 40.392 -91.385 40.402 -91.372 40.447 -91.385 40.503 -91.374 40.528 -91.382 40.547 -91.412 40.572 -91.411 40.603 -91.375 40.639 -91.262 40.643 -91.214 40.656 -91.162 40.682 -91.129 40.705 -91.119 40.761 -91.092 40.833 -91.088 40.879 -91.049 40.923 -90.983 40.951 -90.961 41.071 -90.954 41.104 -90.957 41.144 -90.991 41.165 -91.018 41.176 -91.056 41.231 -91.101 41.267 -91.102 41.334 -91.073 41.401 -91.055 41.423 -91.027 41.431 -91.001 41.421 -90.949 41.444 -90.844 41.449 -90.779 41.451 -90.708 41.462 -90.658 41.509 -90.601 41.525 -90.541 41.527 -90.454 41.543 -90.434 41.567 -90.423 41.586 -90.348 41.602 -90.339 41.649 -90.341 41.722 -90.326 41.756 -90.304 41.781 -90.255 41.806 -90.195 41.931 -90.154 41.983 -90.142 42.033 -90.151 42.061 -90.168 42.103 -90.166 42.121 -90.176 42.122 -90.191 42.159 -90.231 42.197 -90.323 42.211 -90.367 42.242 -90.407 42.263 -90.417 42.341 -90.427 42.361 -90.441 42.388 -90.491 42.421 -90.563 42.461 -90.605 42.475 -90.648 42.494 -90.651 42.509 -90.638 42.508 -90.419 42.504 -89.923 42.503 -89.834 42.497 -89.401 42.497 -89.359 42.491 -88.939 42.491 -88.764 42.489 -88.706 42.491 -88.297 42.489 -88.194 42.489 -87.797 42.314 -87.836 42.156 -87.761 42.059 -87.671 41.847 -87.612 41.723 -87.529 41.469 -87.532 41.301 -87.532 41.173 -87.531 41.009 -87.532 40.745 -87.532 40.494 -87.537 40.483 -87.535 40.166 -87.535 39.887 -87.535 39.609 -87.535 39.477 -87.538 39.351 -87.541 39.338 -87.597 39.307 -87.625 39.297 -87.611 39.281 -87.615 39.258 -87.606 39.248 -87.584 39.208 -87.588 39.198 -87.594 39.196 -87.607 39.168 -87.644 39.146 -87.671 39.131 -87.659 39.113 -87.662 39.103 -87.631 39.088 -87.631 39.084 -87.612 39.062 -87.585 38.995 -87.581 38.994 -87.591 38.977 -87.547 38.963 -87.533 38.931 -87.531 38.904 -87.539 38.869 -87.559 38.857 -87.551 38.795 -87.507 38.776 -87.519 38.769 -87.508 38.736 -87.508 38.685 -87.543 38.672 -87.588 38.642 -87.625 38.622 -87.628 38.599 -87.619 38.593 -87.641 38.573 -87.652 38.547 -87.672 38.515 -87.651 38.501 -87.653 38.504 -87.679 38.481 -87.692 38.466 -87.756 38.457 -87.758 38.445 -87.738 38.417 -87.748 38.378 -87.784 38.352 -87.834 38.286 -87.851 38.285 -87.863 38.316 -87.874 38.315 -87.883 38.301 -87.888 38.281 -87.914 38.302 -87.913 38.304 -87.925 38.241 -87.981 38.234 -87.986 38.201 -87.977 38.171 -87.932 38.157 -87.931 38.136 -87.951 38.131 -87.973 38.103 -88.018 38.092 -88.012 38.096 -87.964 38.073 -87.975 38.054 -88.034 38.045 -88.043 38.038 -88.041 38.033 -88.021 38.008 -88.029 37.975 -88.021 37.956 -88.042 37.934 -88.041 37.929 -88.064 37.944 -88.078 37.923 -88.084 37.917 -88.031 37.905 -88.026 37.896 -88.044 37.906 -88.101 37.895 -88.101 37.867 -88.075 37.843 -88.034 37.827 -88.042 37.831 -88.089 37.817 -88.086 37.805 -88.035 37.735 -88.072 37.701 -88.133 37.661 -88.159 37.628 -88.157 37.583 -88.134 37.511 -88.071</gml:posList></gml:LinearRing></gml:exterior></gml:Polygon></gml:polygonMember></gml:MultiPolygon></topp:the_geom><topp:STATE_NAME>Illinois</topp:STATE_NAME><topp:STATE_FIPS>17</topp:STATE_FIPS><topp:SUB_REGION>E N Cen</topp:SUB_REGION><topp:STATE_ABBR>IL</topp:STATE_ABBR><topp:LAND_KM>143986.61</topp:LAND_KM><topp:WATER_KM>1993.335</topp:WATER_KM><topp:PERSONS>1.143E7</topp:PERSONS><topp:FAMILIES>2924880.0</topp:FAMILIES><topp:HOUSHOLD>4202240.0</topp:HOUSHOLD><topp:MALE>5552233.0</topp:MALE><topp:FEMALE>5878369.0</topp:FEMALE><topp:WORKERS>4199206.0</topp:WORKERS><topp:DRVALONE>3741715.0</topp:DRVALONE><topp:CARPOOL>652603.0</topp:CARPOOL><topp:PUBTRANS>538071.0</topp:PUBTRANS><topp:EMPLOYED>5417967.0</topp:EMPLOYED><topp:UNEMPLOY>385040.0</topp:UNEMPLOY><topp:SERVICE>1360159.0</topp:SERVICE><topp:MANUAL>828906.0</topp:MANUAL><topp:P_MALE>0.486</topp:P_MALE><topp:P_FEMALE>0.514</topp:P_FEMALE><topp:SAMP_POP>1747776.0</topp:SAMP_POP></topp:states><topp:states fid="states.2"><topp:the_geom><gml:MultiPolygon srsName="urn:x-ogc:def:crs:EPSG:4326"><gml:polygonMember><gml:Polygon><gml:exterior><gml:LinearRing><gml:posList>38.966 -77.008 38.889 -76.911 38.788 -77.045 38.813 -77.035 38.829 -77.045 38.838 -77.041 38.862 -77.039 38.886 -77.067 38.915 -77.078 38.932 -77.122 38.993 -77.042 38.966 -77.008</gml:posList></gml:LinearRing></gml:exterior></gml:Polygon></gml:polygonMember></gml:MultiPolygon></topp:the_geom><topp:STATE_NAME>District of Columbia</topp:STATE_NAME><topp:STATE_FIPS>11</topp:STATE_FIPS><topp:SUB_REGION>S Atl</topp:SUB_REGION><topp:STATE_ABBR>DC</topp:STATE_ABBR><topp:LAND_KM>159.055</topp:LAND_KM><topp:WATER_KM>17.991</topp:WATER_KM><topp:PERSONS>606900.0</topp:PERSONS><topp:FAMILIES>122087.0</topp:FAMILIES><topp:HOUSHOLD>249634.0</topp:HOUSHOLD><topp:MALE>282970.0</topp:MALE><topp:FEMALE>323930.0</topp:FEMALE><topp:WORKERS>229975.0</topp:WORKERS><topp:DRVALONE>106694.0</topp:DRVALONE><topp:CARPOOL>36621.0</topp:CARPOOL><topp:PUBTRANS>111422.0</topp:PUBTRANS><topp:EMPLOYED>303994.0</topp:EMPLOYED><topp:UNEMPLOY>23442.0</topp:UNEMPLOY><topp:SERVICE>65498.0</topp:SERVICE><topp:MANUAL>22407.0</topp:MANUAL><topp:P_MALE>0.466</topp:P_MALE><topp:P_FEMALE>0.534</topp:P_FEMALE><topp:SAMP_POP>72696.0</topp:SAMP_POP></topp:states><topp:states fid="states.3"><topp:the_geom><gml:MultiPolygon srsName="urn:x-ogc:def:crs:EPSG:4326"><gml:polygonMember><gml:Polygon><gml:exterior><gml:LinearRing><gml:posList>38.557 -75.707 38.649 -75.711 38.831 -75.724 39.141 -75.752 39.247 -75.761 39.295 -75.764 39.383 -75.772 39.723 -75.791 39.724 -75.775 39.774 -75.745 39.821 -75.695 39.838 -75.644 39.841 -75.583 39.826 -75.471 39.798 -75.421 39.789 -75.412 39.778 -75.428 39.763 -75.461 39.741 -75.475 39.719 -75.476 39.714 -75.489 39.612 -75.611 39.566 -75.562 39.463 -75.591 39.366 -75.515 39.257 -75.402 39.073 -75.397 39.012 -75.324 38.945 -75.307 38.808 -75.191 38.799 -75.083 38.449 -75.045 38.449 -75.068 38.451 -75.093 38.455 -75.351 38.463 -75.699 38.557 -75.707</gml:posList></gml:LinearRing></gml:exterior></gml:Polygon></gml:polygonMember></gml:MultiPolygon></topp:the_geom><topp:STATE_NAME>Delaware</topp:STATE_NAME><topp:STATE_FIPS>10</topp:STATE_FIPS><topp:SUB_REGION>S Atl</topp:SUB_REGION><topp:STATE_ABBR>DE</topp:STATE_ABBR><topp:LAND_KM>5062.456</topp:LAND_KM><topp:WATER_KM>1385.022</topp:WATER_KM><topp:PERSONS>666168.0</topp:PERSONS><topp:FAMILIES>175867.0</topp:FAMILIES><topp:HOUSHOLD>247497.0</topp:HOUSHOLD><topp:MALE>322968.0</topp:MALE><topp:FEMALE>343200.0</topp:FEMALE><topp:WORKERS>247566.0</topp:WORKERS><topp:DRVALONE>258087.0</topp:DRVALONE><topp:CARPOOL>42968.0</topp:CARPOOL><topp:PUBTRANS>8069.0</topp:PUBTRANS><topp:EMPLOYED>335147.0</topp:EMPLOYED><topp:UNEMPLOY>13945.0</topp:UNEMPLOY><topp:SERVICE>87973.0</topp:SERVICE><topp:MANUAL>44140.0</topp:MANUAL><topp:P_MALE>0.485</topp:P_MALE><topp:P_FEMALE>0.515</topp:P_FEMALE><topp:SAMP_POP>102776.0</topp:SAMP_POP></topp:states></gml:featureMembers>
+--></div>
+<div id="v3/topp-states-wfs.xml"><!--
+<?xml version="1.0" encoding="UTF-8"?>
+<wfs:FeatureCollection numberOfFeatures="3" timeStamp="2008-09-12T00:24:21.013-04:00" xsi:schemaLocation="http://www.openplans.org/topp http://sigma.openplans.org:80/geoserver/wfs?service=WFS&amp;version=1.1.0&amp;request=DescribeFeatureType&amp;typeName=topp:states http://www.opengis.net/wfs http://sigma.openplans.org:80/geoserver/schemas/wfs/1.1.0/wfs.xsd" xmlns:ogc="http://www.opengis.net/ogc" xmlns:opengeo="http://open-geo.com" xmlns:tiger="http://www.census.gov" xmlns:wfs="http://www.opengis.net/wfs" xmlns:topp="http://www.openplans.org/topp" xmlns:seb="http://seb.com" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ows="http://www.opengis.net/ows" xmlns:gml="http://www.opengis.net/gml" xmlns:xlink="http://www.w3.org/1999/xlink"><gml:featureMembers><topp:states gml:id="states.1"><gml:boundedBy><gml:Envelope srsName="urn:x-ogc:def:crs:EPSG:4326"><gml:lowerCorner>36.986 -91.516</gml:lowerCorner><gml:upperCorner>42.509 -87.507</gml:upperCorner></gml:Envelope></gml:boundedBy><topp:the_geom><gml:MultiSurface srsName="urn:x-ogc:def:crs:EPSG:4326"><gml:surfaceMember><gml:Polygon><gml:exterior><gml:LinearRing><gml:posList>37.511 -88.071 37.476 -88.087 37.442 -88.311 37.409 -88.359 37.421 -88.419 37.401 -88.467 37.296 -88.511 37.257 -88.501 37.205 -88.451 37.156 -88.422 37.098 -88.451 37.072 -88.476 37.068 -88.491 37.064 -88.517 37.072 -88.559 37.109 -88.614 37.135 -88.688 37.141 -88.739 37.152 -88.746 37.202 -88.863 37.218 -88.932 37.221 -88.993 37.185 -89.065 37.112 -89.116 37.093 -89.146 37.064 -89.169 37.025 -89.174 36.998 -89.151 36.988 -89.129 36.986 -89.193 37.028 -89.211 37.041 -89.237 37.087 -89.264 37.091 -89.284 37.085 -89.303 37.061 -89.309 37.027 -89.264 37.008 -89.262 36.999 -89.282 37.009 -89.311 37.049 -89.382 37.099 -89.379 37.137 -89.423 37.165 -89.441 37.224 -89.468 37.253 -89.465 37.256 -89.489 37.276 -89.513 37.304 -89.513 37.329 -89.501 37.339 -89.468 37.355 -89.435 37.411 -89.427 37.453 -89.453 37.491 -89.494 37.571 -89.524 37.615 -89.513 37.651 -89.519 37.679 -89.513 37.694 -89.521 37.706 -89.581 37.745 -89.666 37.783 -89.675 37.804 -89.691 37.841 -89.728 37.905 -89.851 37.905 -89.861 37.891 -89.866 37.875 -89.901 37.878 -89.937 37.911 -89.978 37.963 -89.958 37.969 -90.011 37.993 -90.041 38.032 -90.119 38.053 -90.134 38.088 -90.207 38.122 -90.254 38.166 -90.289 38.188 -90.336 38.234 -90.364 38.323 -90.369 38.365 -90.358 38.391 -90.339 38.427 -90.301 38.518 -90.265 38.532 -90.261 38.562 -90.241 38.611 -90.183 38.658 -90.183 38.701 -90.202 38.723 -90.196 38.773 -90.163 38.785 -90.135 38.801 -90.121 38.831 -90.113 38.853 -90.132 38.914 -90.243 38.924 -90.278 38.924 -90.319 38.962 -90.413 38.959 -90.469 38.891 -90.531 38.871 -90.571 38.881 -90.627 38.935 -90.668 39.037 -90.706 39.058 -90.707 39.093 -90.691 39.144 -90.716 39.195 -90.718 39.224 -90.732 39.247 -90.738 39.296 -90.779 39.351 -90.851 39.401 -90.947 39.444 -91.036 39.473 -91.064 39.528 -91.093 39.552 -91.156 39.601 -91.203 39.685 -91.317 39.724 -91.367 39.761 -91.373 39.803 -91.381 39.863 -91.449 39.885 -91.451 39.901 -91.434 39.921 -91.431 39.946 -91.447 40.005 -91.487 40.066 -91.504 40.134 -91.516 40.201 -91.506 40.251 -91.498 40.309 -91.486 40.371 -91.448 40.386 -91.418 40.392 -91.385 40.402 -91.372 40.447 -91.385 40.503 -91.374 40.528 -91.382 40.547 -91.412 40.572 -91.411 40.603 -91.375 40.639 -91.262 40.643 -91.214 40.656 -91.162 40.682 -91.129 40.705 -91.119 40.761 -91.092 40.833 -91.088 40.879 -91.049 40.923 -90.983 40.951 -90.961 41.071 -90.954 41.104 -90.957 41.144 -90.991 41.165 -91.018 41.176 -91.056 41.231 -91.101 41.267 -91.102 41.334 -91.073 41.401 -91.055 41.423 -91.027 41.431 -91.001 41.421 -90.949 41.444 -90.844 41.449 -90.779 41.451 -90.708 41.462 -90.658 41.509 -90.601 41.525 -90.541 41.527 -90.454 41.543 -90.434 41.567 -90.423 41.586 -90.348 41.602 -90.339 41.649 -90.341 41.722 -90.326 41.756 -90.304 41.781 -90.255 41.806 -90.195 41.931 -90.154 41.983 -90.142 42.033 -90.151 42.061 -90.168 42.103 -90.166 42.121 -90.176 42.122 -90.191 42.159 -90.231 42.197 -90.323 42.211 -90.367 42.242 -90.407 42.263 -90.417 42.341 -90.427 42.361 -90.441 42.388 -90.491 42.421 -90.563 42.461 -90.605 42.475 -90.648 42.494 -90.651 42.509 -90.638 42.508 -90.419 42.504 -89.923 42.503 -89.834 42.497 -89.401 42.497 -89.359 42.491 -88.939 42.491 -88.764 42.489 -88.706 42.491 -88.297 42.489 -88.194 42.489 -87.797 42.314 -87.836 42.156 -87.761 42.059 -87.671 41.847 -87.612 41.723 -87.529 41.469 -87.532 41.301 -87.532 41.173 -87.531 41.009 -87.532 40.745 -87.532 40.494 -87.537 40.483 -87.535 40.166 -87.535 39.887 -87.535 39.609 -87.535 39.477 -87.538 39.351 -87.541 39.338 -87.597 39.307 -87.625 39.297 -87.611 39.281 -87.615 39.258 -87.606 39.248 -87.584 39.208 -87.588 39.198 -87.594 39.196 -87.607 39.168 -87.644 39.146 -87.671 39.131 -87.659 39.113 -87.662 39.103 -87.631 39.088 -87.631 39.084 -87.612 39.062 -87.585 38.995 -87.581 38.994 -87.591 38.977 -87.547 38.963 -87.533 38.931 -87.531 38.904 -87.539 38.869 -87.559 38.857 -87.551 38.795 -87.507 38.776 -87.519 38.769 -87.508 38.736 -87.508 38.685 -87.543 38.672 -87.588 38.642 -87.625 38.622 -87.628 38.599 -87.619 38.593 -87.641 38.573 -87.652 38.547 -87.672 38.515 -87.651 38.501 -87.653 38.504 -87.679 38.481 -87.692 38.466 -87.756 38.457 -87.758 38.445 -87.738 38.417 -87.748 38.378 -87.784 38.352 -87.834 38.286 -87.851 38.285 -87.863 38.316 -87.874 38.315 -87.883 38.301 -87.888 38.281 -87.914 38.302 -87.913 38.304 -87.925 38.241 -87.981 38.234 -87.986 38.201 -87.977 38.171 -87.932 38.157 -87.931 38.136 -87.951 38.131 -87.973 38.103 -88.018 38.092 -88.012 38.096 -87.964 38.073 -87.975 38.054 -88.034 38.045 -88.043 38.038 -88.041 38.033 -88.021 38.008 -88.029 37.975 -88.021 37.956 -88.042 37.934 -88.041 37.929 -88.064 37.944 -88.078 37.923 -88.084 37.917 -88.031 37.905 -88.026 37.896 -88.044 37.906 -88.101 37.895 -88.101 37.867 -88.075 37.843 -88.034 37.827 -88.042 37.831 -88.089 37.817 -88.086 37.805 -88.035 37.735 -88.072 37.701 -88.133 37.661 -88.159 37.628 -88.157 37.583 -88.134 37.511 -88.071</gml:posList></gml:LinearRing></gml:exterior></gml:Polygon></gml:surfaceMember></gml:MultiSurface></topp:the_geom><topp:STATE_NAME>Illinois</topp:STATE_NAME><topp:STATE_FIPS>17</topp:STATE_FIPS><topp:SUB_REGION>E N Cen</topp:SUB_REGION><topp:STATE_ABBR>IL</topp:STATE_ABBR><topp:LAND_KM>143986.61</topp:LAND_KM><topp:WATER_KM>1993.335</topp:WATER_KM><topp:PERSONS>1.143E7</topp:PERSONS><topp:FAMILIES>2924880.0</topp:FAMILIES><topp:HOUSHOLD>4202240.0</topp:HOUSHOLD><topp:MALE>5552233.0</topp:MALE><topp:FEMALE>5878369.0</topp:FEMALE><topp:WORKERS>4199206.0</topp:WORKERS><topp:DRVALONE>3741715.0</topp:DRVALONE><topp:CARPOOL>652603.0</topp:CARPOOL><topp:PUBTRANS>538071.0</topp:PUBTRANS><topp:EMPLOYED>5417967.0</topp:EMPLOYED><topp:UNEMPLOY>385040.0</topp:UNEMPLOY><topp:SERVICE>1360159.0</topp:SERVICE><topp:MANUAL>828906.0</topp:MANUAL><topp:P_MALE>0.486</topp:P_MALE><topp:P_FEMALE>0.514</topp:P_FEMALE><topp:SAMP_POP>1747776.0</topp:SAMP_POP></topp:states><topp:states gml:id="states.2"><gml:boundedBy><gml:Envelope srsName="urn:x-ogc:def:crs:EPSG:4326"><gml:lowerCorner>38.788 -77.122</gml:lowerCorner><gml:upperCorner>38.993 -76.911</gml:upperCorner></gml:Envelope></gml:boundedBy><topp:the_geom><gml:MultiSurface srsName="urn:x-ogc:def:crs:EPSG:4326"><gml:surfaceMember><gml:Polygon><gml:exterior><gml:LinearRing><gml:posList>38.966 -77.008 38.889 -76.911 38.788 -77.045 38.813 -77.035 38.829 -77.045 38.838 -77.041 38.862 -77.039 38.886 -77.067 38.915 -77.078 38.932 -77.122 38.993 -77.042 38.966 -77.008</gml:posList></gml:LinearRing></gml:exterior></gml:Polygon></gml:surfaceMember></gml:MultiSurface></topp:the_geom><topp:STATE_NAME>District of Columbia</topp:STATE_NAME><topp:STATE_FIPS>11</topp:STATE_FIPS><topp:SUB_REGION>S Atl</topp:SUB_REGION><topp:STATE_ABBR>DC</topp:STATE_ABBR><topp:LAND_KM>159.055</topp:LAND_KM><topp:WATER_KM>17.991</topp:WATER_KM><topp:PERSONS>606900.0</topp:PERSONS><topp:FAMILIES>122087.0</topp:FAMILIES><topp:HOUSHOLD>249634.0</topp:HOUSHOLD><topp:MALE>282970.0</topp:MALE><topp:FEMALE>323930.0</topp:FEMALE><topp:WORKERS>229975.0</topp:WORKERS><topp:DRVALONE>106694.0</topp:DRVALONE><topp:CARPOOL>36621.0</topp:CARPOOL><topp:PUBTRANS>111422.0</topp:PUBTRANS><topp:EMPLOYED>303994.0</topp:EMPLOYED><topp:UNEMPLOY>23442.0</topp:UNEMPLOY><topp:SERVICE>65498.0</topp:SERVICE><topp:MANUAL>22407.0</topp:MANUAL><topp:P_MALE>0.466</topp:P_MALE><topp:P_FEMALE>0.534</topp:P_FEMALE><topp:SAMP_POP>72696.0</topp:SAMP_POP></topp:states><topp:states gml:id="states.3"><gml:boundedBy><gml:Envelope srsName="urn:x-ogc:def:crs:EPSG:4326"><gml:lowerCorner>38.449 -75.791</gml:lowerCorner><gml:upperCorner>39.841 -75.045</gml:upperCorner></gml:Envelope></gml:boundedBy><topp:the_geom><gml:MultiSurface srsName="urn:x-ogc:def:crs:EPSG:4326"><gml:surfaceMember><gml:Polygon><gml:exterior><gml:LinearRing><gml:posList>38.557 -75.707 38.649 -75.711 38.831 -75.724 39.141 -75.752 39.247 -75.761 39.295 -75.764 39.383 -75.772 39.723 -75.791 39.724 -75.775 39.774 -75.745 39.821 -75.695 39.838 -75.644 39.841 -75.583 39.826 -75.471 39.798 -75.421 39.789 -75.412 39.778 -75.428 39.763 -75.461 39.741 -75.475 39.719 -75.476 39.714 -75.489 39.612 -75.611 39.566 -75.562 39.463 -75.591 39.366 -75.515 39.257 -75.402 39.073 -75.397 39.012 -75.324 38.945 -75.307 38.808 -75.191 38.799 -75.083 38.449 -75.045 38.449 -75.068 38.451 -75.093 38.455 -75.351 38.463 -75.699 38.557 -75.707</gml:posList></gml:LinearRing></gml:exterior></gml:Polygon></gml:surfaceMember></gml:MultiSurface></topp:the_geom><topp:STATE_NAME>Delaware</topp:STATE_NAME><topp:STATE_FIPS>10</topp:STATE_FIPS><topp:SUB_REGION>S Atl</topp:SUB_REGION><topp:STATE_ABBR>DE</topp:STATE_ABBR><topp:LAND_KM>5062.456</topp:LAND_KM><topp:WATER_KM>1385.022</topp:WATER_KM><topp:PERSONS>666168.0</topp:PERSONS><topp:FAMILIES>175867.0</topp:FAMILIES><topp:HOUSHOLD>247497.0</topp:HOUSHOLD><topp:MALE>322968.0</topp:MALE><topp:FEMALE>343200.0</topp:FEMALE><topp:WORKERS>247566.0</topp:WORKERS><topp:DRVALONE>258087.0</topp:DRVALONE><topp:CARPOOL>42968.0</topp:CARPOOL><topp:PUBTRANS>8069.0</topp:PUBTRANS><topp:EMPLOYED>335147.0</topp:EMPLOYED><topp:UNEMPLOY>13945.0</topp:UNEMPLOY><topp:SERVICE>87973.0</topp:SERVICE><topp:MANUAL>44140.0</topp:MANUAL><topp:P_MALE>0.485</topp:P_MALE><topp:P_FEMALE>0.515</topp:P_FEMALE><topp:SAMP_POP>102776.0</topp:SAMP_POP></topp:states></gml:featureMembers></wfs:FeatureCollection>
+--></div>
+<div id="v2/point-coord.xml"><!--
+<gml:Point xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+  <gml:coord>
+    <gml:X>1</gml:X>
+    <gml:Y>2</gml:Y>
+  </gml:coord>
+</gml:Point>
+--></div>
+<div id="v2/point-coordinates.xml"><!--
+<gml:Point xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+  <gml:coordinates decimal="." cs="," ts=" ">1,2</gml:coordinates>
+</gml:Point>
+--></div>
+<div id="v2/linestring-coord.xml"><!--
+<gml:LineString xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+  <gml:coord>
+    <gml:X>1</gml:X>
+    <gml:Y>2</gml:Y>
+  </gml:coord>
+  <gml:coord>
+    <gml:X>3</gml:X>
+    <gml:Y>4</gml:Y>
+  </gml:coord>
+</gml:LineString>
+--></div>
+<div id="v2/linestring-coordinates.xml"><!--
+<gml:LineString xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+  <gml:coordinates decimal="." cs="," ts=" ">1,2 3,4</gml:coordinates>
+</gml:LineString>
+--></div>
+<div id="v2/multipoint-coord.xml"><!--
+<gml:MultiPoint xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:pointMember>
+        <gml:Point>
+            <gml:coord>
+                <gml:X>1</gml:X>
+                <gml:Y>2</gml:Y>
+            </gml:coord>
+        </gml:Point>
+    </gml:pointMember>
+    <gml:pointMember>
+        <gml:Point>
+            <gml:coord>
+                <gml:X>2</gml:X>
+                <gml:Y>3</gml:Y>
+            </gml:coord>
+        </gml:Point>
+    </gml:pointMember>
+    <gml:pointMember>
+        <gml:Point>
+            <gml:coord>
+                <gml:X>3</gml:X>
+                <gml:Y>4</gml:Y>
+            </gml:coord>
+        </gml:Point>
+    </gml:pointMember>
+</gml:MultiPoint>
+--></div>
+<div id="v2/multipoint-coordinates.xml"><!--
+<gml:MultiPoint xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:pointMember>
+        <gml:Point>
+            <gml:coordinates decimal="." cs="," ts=" ">1,2</gml:coordinates>
+        </gml:Point>
+    </gml:pointMember>
+    <gml:pointMember>
+        <gml:Point>
+            <gml:coordinates decimal="." cs="," ts=" ">2,3</gml:coordinates>
+        </gml:Point>
+    </gml:pointMember>
+    <gml:pointMember>
+        <gml:Point>
+            <gml:coordinates decimal="." cs="," ts=" ">3,4</gml:coordinates>
+        </gml:Point>
+    </gml:pointMember>
+</gml:MultiPoint>
+--></div>
+<div id="v2/multilinestring-coord.xml"><!--
+<gml:MultiLineString xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:lineStringMember>
+        <gml:LineString>
+            <gml:coord>
+                <gml:X>1</gml:X>
+                <gml:Y>2</gml:Y>
+            </gml:coord>
+            <gml:coord>
+                <gml:X>2</gml:X>
+                <gml:Y>3</gml:Y>
+            </gml:coord>
+        </gml:LineString>
+    </gml:lineStringMember>
+    <gml:lineStringMember>
+        <gml:LineString>
+            <gml:coord>
+                <gml:X>3</gml:X>
+                <gml:Y>4</gml:Y>
+            </gml:coord>
+            <gml:coord>
+                <gml:X>4</gml:X>
+                <gml:Y>5</gml:Y>
+            </gml:coord>
+        </gml:LineString>
+    </gml:lineStringMember>
+</gml:MultiLineString>
+--></div>
+<div id="v2/multilinestring-coordinates.xml"><!--
+<gml:MultiLineString xmlns:gml="http://www.opengis.net/gml" srsName="foo">
+    <gml:lineStringMember>
+        <gml:LineString>
+            <gml:coordinates decimal="." cs="," ts=" ">1,2 2,3</gml:coordinates>
+        </gml:LineString>
+    </gml:lineStringMember>
+    <gml:lineStringMember>
+        <gml:LineString>
+            <gml:coordinates decimal="." cs="," ts=" ">3,4 4,5</gml:coordinates>
+        </gml:LineString>
+    </gml:lineStringMember>
+</gml:MultiLineString>
+--></div>
+</body>
+</html>
diff --git a/tests/Format/XML.html b/tests/Format/XML.html
index aff544e134..e58dace6e4 100644
--- a/tests/Format/XML.html
+++ b/tests/Format/XML.html
@@ -27,7 +27,7 @@
         '<' + '/ol:root>';
 
     function test_Format_XML_constructor(t) { 
-        t.plan(5); 
+        t.plan(13); 
          
         var options = {'foo': 'bar'}; 
         var format = new OpenLayers.Format.XML(options); 
@@ -38,6 +38,36 @@
         t.eq(typeof format.write, "function", "format has a write function");
 
         t.ok(!window.ActiveXObject || format.xmldom, "browsers with activeX must have xmldom");
+        
+        // test namespaces
+        t.ok(format.namespaces instanceof Object, "format has namespace object");
+        var namespaces = {"foo": "bar"};
+        format = new OpenLayers.Format.XML({namespaces: namespaces});
+        t.eq(format.namespaces, namespaces, "format.namespaces correctly set in constructor");
+        
+        // test default prefix
+        t.eq(format.defaultPrefix, null, "defaultPrefix is null by default");
+        format = new OpenLayers.Format.XML({defaultPrefix: "foo"});
+        t.eq(format.defaultPrefix, "foo", "defaultPrefix correctly set in constructor");
+
+        // test readers
+        t.ok(format.readers instanceof Object, "format has readers object");
+        var readers = {"foo": "bar"};
+        format = new OpenLayers.Format.XML({readers: readers});
+        t.eq(format.readers, readers, "format.readers correctly set in constructor");
+
+        // test readers
+        t.ok(format.writers instanceof Object, "format has writers object");
+        var writers = {"foo": "bar"};
+        format = new OpenLayers.Format.XML({writers: writers});
+        t.eq(format.writers, writers, "format.writers correctly set in constructor");
+    }
+    
+    function test_destroy(t) {
+        t.plan(1);
+        var format = new OpenLayers.Format.XML();
+        format.destroy();
+        t.eq(format.xmldom, null, "xmldom set to null for all browsers");
     }
 
     function test_Format_XML_read(t) {
@@ -260,6 +290,363 @@
         found = format.hasAttributeNS(nodes[0], taUri, "nothing");
         t.ok(found === false, "returns false for bad attribute");
     }
+    
+    function test_namespaces(t) {
+        t.plan(2);
+        
+        var format = new OpenLayers.Format.XML({
+            namespaces: {
+                "def": "http://example.com/default",
+                "foo": "http://example.com/foo",
+                "bar": "http://example.com/bar"
+            },
+            defaultPrefix: "def"
+        });
+        
+        // test that prototype has not been altered
+        t.eq(OpenLayers.Format.XML.prototype.namespaces, null,
+             "setting namespaces at construction does not modify prototype");
+        
+        // test that namespaceAlias has been set
+        t.eq(format.namespaceAlias["http://example.com/foo"], "foo",
+             "namespaceAlias mapping has been set");
+        
+    }
+    
+    function test_setNamespace(t) {
+        t.plan(3);
+        
+        var format = new OpenLayers.Format.XML();
+        
+        // test that namespaces is an object
+        t.ok(format.namespaces instanceof Object, "empty namespace object set");
+        
+        format.setNamespace("foo", "http://example.com/foo");
+        t.eq(format.namespaces["foo"], "http://example.com/foo", "alias -> uri mapping set");
+        t.eq(format.namespaceAlias["http://example.com/foo"], "foo", "uri -> alias mapping set");
+
+    }
+    
+    function test_readChildNodes(t) {
+        
+        var text = "<?xml version='1.0' encoding='UTF-8'?>" +
+        "<container xmlns='http://example.com/foo'>" +
+            "<marker name='my marker 1'>" +
+                "<position>" +
+                    "<lon>-180</lon>" +
+                    "<lat>90</lat>" +
+                "</position>" +
+                "<detail>some text for first marker</detail>" +
+                "<atom:link xmlns:atom='http://www.w3.org/2005/Atom' href='http://host/path/1'/>" +
+            "</marker>" +
+            "<marker name='my marker 2'>" +
+                "<position>" +
+                    "<lon>180</lon>" +
+                    "<lat>-90</lat>" +
+                "</position>" +
+                "<detail>some text for second marker</detail>" +
+                "<atom:link xmlns:atom='http://www.w3.org/2005/Atom' href='http://host/path/2'/>" +
+            "</marker>" +
+        "</container>";
+        
+        var expect = [
+            new OpenLayers.Feature.Vector(
+                new OpenLayers.Geometry.Point(-180, 90),
+                {
+                    name: 'my marker 1',
+                    link: 'http://host/path/1',
+                    detail: 'some text for first marker'
+                }
+            ),
+            new OpenLayers.Feature.Vector(
+                new OpenLayers.Geometry.Point(180, -90),
+                {
+                    name: 'my marker 2',
+                    link: 'http://host/path/2',
+                    detail: 'some text for second marker'
+                }
+            )
+        ];
+        
+        var format = new OpenLayers.Format.XML({
+            defaultPrefix: "foo",
+            namespaces: {
+                "foo": "http://example.com/foo",
+                "atom": "http://www.w3.org/2005/Atom"
+            },
+            readers: {
+                "foo": {
+                    "container": function(node, obj) {
+                        var list = [];
+                        this.readChildNodes(node, list);
+                        obj.list = list;
+                    },
+                    "marker": function(node, list) {
+                        var feature = new OpenLayers.Feature.Vector();
+                        feature.attributes.name = node.getAttribute("name");
+                        this.readChildNodes(node, feature);
+                        list.push(feature);
+                    },
+                    "position": function(node, feature) {
+                        var obj = {};
+                        this.readChildNodes(node, obj);
+                        feature.geometry = new OpenLayers.Geometry.Point(obj.x, obj.y);
+                    },
+                    "lon": function(node, obj) {
+                        obj.x = this.getChildValue(node);
+                    },
+                    "lat": function(node, obj) {
+                        obj.y = this.getChildValue(node);
+                    },
+                    "detail": function(node, feature) {
+                        feature.attributes.detail = this.getChildValue(node);
+                    }
+                },
+                "atom": {
+                    "link": function(node, feature) {
+                        feature.attributes.link = node.getAttribute("href");
+                    }                    
+                }
+            }
+        });
+        
+        // convert text to document node
+        var doc = format.read(text);
+        // read child nodes to get back some object
+        var obj = format.readChildNodes(doc);
+        // start comparing what we got to what we expect
+        var got = obj.list;
+        
+        t.plan(11);
+        t.eq(got.length, expect.length, "correct number of items parsed");
+        t.eq(got[0].geometry.x, expect[0].geometry.x, "correct x coord parsed for marker 1");
+        t.eq(got[0].geometry.y, expect[0].geometry.y, "correct y coord parsed for marker 1");
+        t.eq(got[0].attributes.name, expect[0].attributes.name, "correct name parsed for marker 1");
+        t.eq(got[0].attributes.detail, expect[0].attributes.detail, "correct detail parsed for marker 1");
+        t.eq(got[0].attributes.link, expect[0].attributes.link, "correct link parsed for marker 1");
+        t.eq(got[1].geometry.x, expect[1].geometry.x, "correct x coord parsed for marker 2");
+        t.eq(got[1].geometry.y, expect[1].geometry.y, "correct y coord parsed for marker 2");
+        t.eq(got[1].attributes.name, expect[1].attributes.name, "correct name parsed for marker 2");
+        t.eq(got[1].attributes.detail, expect[1].attributes.detail, "correct detail parsed for marker 2");
+        t.eq(got[1].attributes.link, expect[1].attributes.link, "correct link parsed for marker 2");
+        
+    }
+    
+    function test_writeNode(t) {
+        
+        var features = [
+            new OpenLayers.Feature.Vector(
+                new OpenLayers.Geometry.Point(-180, 90),
+                {
+                    name: 'my marker 1',
+                    link: 'http://host/path/1',
+                    detail: 'some text for first marker'
+                }
+            ),
+            new OpenLayers.Feature.Vector(
+                new OpenLayers.Geometry.Point(180, -90),
+                {
+                    name: 'my marker 2',
+                    link: 'http://host/path/2',
+                    detail: 'some text for second marker'
+                }
+            )
+        ];
+
+        var expect = "<?xml version='1.0' encoding='UTF-8'?>" +
+        "<container xmlns='http://example.com/foo'>" +
+            "<marker name='my marker 1'>" +
+                "<position>" +
+                    "<lon>-180</lon>" +
+                    "<lat>90</lat>" +
+                "</position>" +
+                "<detail>some text for first marker</detail>" +
+                "<atom:link xmlns:atom='http://www.w3.org/2005/Atom' href='http://host/path/1'/>" +
+            "</marker>" +
+            "<marker name='my marker 2'>" +
+                "<position>" +
+                    "<lon>180</lon>" +
+                    "<lat>-90</lat>" +
+                "</position>" +
+                "<detail>some text for second marker</detail>" +
+                "<atom:link xmlns:atom='http://www.w3.org/2005/Atom' href='http://host/path/2'/>" +
+            "</marker>" +
+        "</container>";
+        
+        var format = new OpenLayers.Format.XML({
+            defaultPrefix: "foo",
+            namespaces: {
+                "foo": "http://example.com/foo",
+                "atom": "http://www.w3.org/2005/Atom"
+            },
+            writers: {
+                "foo": {
+                    "container": function(features) {
+                        var node = this.createElementNSPlus("container");
+                        var feature;
+                        for(var i=0; i<features.length; ++i) {
+                            feature = features[i];
+                            this.writeNode("marker", features[i], node);
+                        }
+                        return node;
+                    },
+                    "marker": function(feature) {
+                        var node = this.createElementNSPlus("marker", {
+                            attributes: {name: feature.attributes.name}
+                        });
+                        this.writeNode("position", feature.geometry, node);
+                        this.writeNode("detail", feature.attributes.detail, node);
+                        this.writeNode("atom:link", feature.attributes.link, node);
+                        return node;
+                    },
+                    "position": function(geometry) {
+                        var node = this.createElementNSPlus("position");
+                        this.writeNode("lon", geometry.x, node);
+                        this.writeNode("lat", geometry.y, node);
+                        return node;
+                    },
+                    "lon": function(x) {
+                        return this.createElementNSPlus("lon", {
+                            value: x
+                        });
+                    },
+                    "lat": function(y) {
+                        return this.createElementNSPlus("lat", {
+                            value: y
+                        });
+                    },
+                    "detail": function(text) {
+                        return this.createElementNSPlus("detail", {
+                            value: text
+                        });
+                    }
+                },
+                "atom": {
+                    "link": function(href) {
+                        return this.createElementNSPlus("atom:link", {
+                            attributes: {href: href}
+                        });
+                    }
+                }
+            }
+            
+        });
+        
+        t.plan(1);
+        // test that we get what we expect from writeNode
+        var got = format.writeNode("container", features);
+        t.xml_eq(got, expect, "features correctly written");
+    }
+    
+    function test_createElementNSPlus(t) {
+        
+        var format = new OpenLayers.Format.XML({
+            defaultPrefix: "def",
+            namespaces: {
+                "def": "http://example.com/default",
+                "foo": "http://example.com/foo",
+                "bar": "http://example.com/bar"
+            }
+        });
+        
+        var cases = [
+            {
+                description: "unprefixed name with default options",
+                node: format.createElementNSPlus("FooNode"),
+                expect: "<def:FooNode xmlns:def='http://example.com/default'/>"
+            }, {
+                description: "def prefixed name with default options",
+                node: format.createElementNSPlus("def:FooNode"),
+                expect: "<def:FooNode xmlns:def='http://example.com/default'/>"
+            }, {
+                description: "foo prefixed name with default options",
+                node: format.createElementNSPlus("foo:FooNode"),
+                expect: "<foo:FooNode xmlns:foo='http://example.com/foo'/>"
+            }, {
+                description: "unprefixed name with uri option",
+                node: format.createElementNSPlus("FooNode", {
+                    uri: "http://example.com/elsewhere"
+                }),
+                expect: "<FooNode xmlns='http://example.com/elsewhere'/>"
+            }, {
+                description: "foo prefixed name with uri option (overriding format.namespaces)",
+                node: format.createElementNSPlus("foo:FooNode", {
+                    uri: "http://example.com/elsewhere"
+                }),
+                expect: "<foo:FooNode xmlns:foo='http://example.com/elsewhere'/>"
+            }, {
+                description: "foo prefixed name with attributes option",
+                node: format.createElementNSPlus("foo:FooNode", {
+                    attributes: {
+                        "id": "123",
+                        "foo:attr1": "namespaced attribute 1",
+                        "bar:attr2": "namespaced attribute 2"
+                    }
+                }),
+                expect: "<foo:FooNode xmlns:foo='http://example.com/foo' xmlns:bar='http://example.com/bar' id='123' foo:attr1='namespaced attribute 1' bar:attr2='namespaced attribute 2'/>"
+            }, {
+                description: "foo prefixed name with attributes and value options",
+                node: format.createElementNSPlus("foo:FooNode", {
+                    attributes: {"id": "123"},
+                    value: "text value"
+                }),
+                expect: "<foo:FooNode xmlns:foo='http://example.com/foo' id='123'>text value<" + "/foo:FooNode>"
+            }
+        ];
+        
+        t.plan(cases.length);
+        var test;
+        for(var i=0; i<cases.length; ++i) {
+            test = cases[i];
+            t.xml_eq(test.node, test.expect, test.description);
+        }
+        
+    }
+    
+    function test_setAttributes(t) {
+        
+        var format = new OpenLayers.Format.XML({
+            defaultPrefix: "def",
+            namespaces: {
+                "def": "http://example.com/default",
+                "foo": "http://example.com/foo",
+                "bar": "http://example.com/bar"
+            }
+        });
+        
+        var cases = [
+            {
+                description: "unprefixed attribute",
+                node: format.createElementNSPlus("foo:Node"),
+                attributes: {"id": "123"},
+                expect: "<foo:Node xmlns:foo='http://example.com/foo' id='123'/>"
+            }, {
+                description: "foo prefixed attribute",
+                node: format.createElementNSPlus("foo:Node"),
+                attributes: {"foo:id": "123"},
+                expect: "<foo:Node xmlns:foo='http://example.com/foo' foo:id='123'/>"
+            }, {
+                description: "foo prefixed attribute with def prefixed node",
+                node: format.createElementNSPlus("def:Node"),
+                attributes: {"foo:id": "123"},
+                expect: "<def:Node xmlns:def='http://example.com/default' xmlns:foo='http://example.com/foo' foo:id='123'/>"
+            }, {
+                description: "multiple attributes",
+                node: format.createElementNSPlus("def:Node"),
+                attributes: {"id": "123", "foo": "bar"},
+                expect: "<def:Node xmlns:def='http://example.com/default' id='123' foo='bar'/>"
+            }
+        ];
+        
+        t.plan(cases.length);
+        var test;
+        for(var i=0; i<cases.length; ++i) {
+            test = cases[i];
+            format.setAttributes(test.node, test.attributes);
+            t.xml_eq(test.node, test.expect, test.description);
+        }
+        
+    }
 
     </script> 
 </head> 
diff --git a/tests/Protocol/HTTP.html b/tests/Protocol/HTTP.html
index 56a27b4476..3892754ae8 100644
--- a/tests/Protocol/HTTP.html
+++ b/tests/Protocol/HTTP.html
@@ -102,6 +102,35 @@
         };
 
         var resp = protocol.read(readOptions);
+
+        OpenLayers.Request.GET = _get;
+    }
+
+    function test_read_bbox(t) {
+        t.plan(1);
+        var protocol = new OpenLayers.Protocol.HTTP();
+
+        // fake XHR request object
+        var request = {'status': 200};
+
+        var _get = OpenLayers.Request.GET;
+
+        var bounds = new OpenLayers.Bounds(1, 2, 3, 4);
+        var filter = new OpenLayers.Filter.Spatial({
+            type: OpenLayers.Filter.Spatial.BBOX,
+            value: bounds,
+            projection: "foo"
+        });
+        
+        OpenLayers.Request.GET = function(options) {
+            t.eq(options.params['bbox'].toString(), bounds.toArray().toString(),
+                'GET called with bbox filter in params');
+            return request;
+        };
+
+        var resp = protocol.read({filter: filter});
+
+        OpenLayers.Request.GET = _get;        
     }
 
     function test_parseFeatures(t) {
@@ -217,6 +246,8 @@
         };
 
         var resp = protocol.create(features, createOptions);
+        
+        OpenLayers.Request.POST = _post;
     }
 
     function test_update(t) {
@@ -284,8 +315,10 @@
         };
 
         var resp = protocol.update(feature, updateOptions);
-
+        
+        OpenLayers.Request.PUT = _put;
     }
+
     function test_handleResponse(t) {
         t.plan(6);
 
@@ -404,6 +437,7 @@
 
         var resp = protocol['delete'](feature, deleteOptions);
 
+        OpenLayers.Request.DELETE = _delete;
     }
 
     function test_handleDelete(t) {
diff --git a/tests/Protocol/SQL.html b/tests/Protocol/SQL.html
new file mode 100644
index 0000000000..01377e0dd3
--- /dev/null
+++ b/tests/Protocol/SQL.html
@@ -0,0 +1,23 @@
+<html>
+<head>
+  <script src="../../lib/OpenLayers.js"></script>
+  <script type="text/javascript">
+
+    function test_initialize(t) {
+        t.plan(3);
+        var options = {tableName: 'my_features', 
+                       databaseName: 'my_database_name'}
+        var protocol = new OpenLayers.Protocol.SQL(options);
+
+        t.ok(protocol instanceof OpenLayers.Protocol.SQL,
+             "new OpenLayers.Protocol.SQL returns object");
+
+        t.eq(protocol.tableName, options.tableName, "tableName property is set");
+        t.eq(protocol.databaseName, options.databaseName, "databaseName property is set");
+    }
+    
+  </script>
+</head>
+<body>
+</body>
+</html>
diff --git a/tests/Protocol/SQL/Gears.html b/tests/Protocol/SQL/Gears.html
new file mode 100644
index 0000000000..6f97f1a0b1
--- /dev/null
+++ b/tests/Protocol/SQL/Gears.html
@@ -0,0 +1,473 @@
+<html>
+<head>
+  <script src="../../../lib/OpenLayers.js"></script>
+  <script type="text/javascript">
+
+    function test_initialize(t) {
+        var protocol = new OpenLayers.Protocol.SQL.Gears();
+        if (!protocol.supported()) {
+            t.plan(0);
+            return;
+        }
+
+        t.plan(5);
+
+        t.eq(protocol.CLASS_NAME, "OpenLayers.Protocol.SQL.Gears",
+             "ctor returns correct value");
+
+        t.eq(protocol.jsonParser.CLASS_NAME,
+             "OpenLayers.Format.JSON",
+             "ctor creates a JSON parser");
+
+        t.eq(protocol.wktParser.CLASS_NAME,
+             "OpenLayers.Format.WKT",
+             "ctor creates a WKT parser");
+
+        var str = protocol.FID_PREFIX + "foo_bar";
+        t.ok(str.match(protocol.fidRegExp),
+             "ctor creates correct regexp");
+
+        t.ok(typeof protocol.db == "object",
+             "ctor creates a db object");
+
+        protocol.clear();
+        protocol.destroy();
+    }
+
+    function test_destroy(t) {
+        var protocol = new OpenLayers.Protocol.SQL.Gears();
+        if (!protocol.supported()) {
+            t.plan(0);
+            return;
+        }
+
+        t.plan(3);
+
+        protocol.destroy();
+
+        t.eq(protocol.db, null,
+             "destroy nullifies db");
+        t.eq(protocol.jsonParser, null,
+             "destroy nullifies jsonParser");
+        t.eq(protocol.wktParser, null,
+             "destroy nullifies wktParser");
+     }
+
+    function test_read(t) {
+        var protocolCallback, readCallback;
+        var protocolOptions = {callback: protocolCallback};
+        var readOptions = {callback: readCallback};
+
+        var protocol = new OpenLayers.Protocol.SQL.Gears(protocolOptions);
+        if (!protocol.supported()) {
+            t.plan(0);
+            return;
+        }
+
+        function okCallback(resp) {
+            t.eq(resp.CLASS_NAME, "OpenLayers.Protocol.Response",
+                 "read calls correct callback with a response object");
+        }
+
+        function failCallback(resp) {
+            t.fail("read calls incorrect callback");
+        }
+
+        t.plan(4);
+
+        var resp;
+
+        // 2 tests
+        protocolOptions.callback = okCallback;
+        readOptions.callback = failCallback;
+        resp = protocol.read();
+        t.eq(resp.CLASS_NAME, "OpenLayers.Protocol.Response",
+             "read returns a response object");
+
+        // 2 test
+        protocolOptions.callback = failCallback;
+        readOptions.callback = okCallback;
+        resp = protocol.read(readOptions);
+        t.eq(resp.CLASS_NAME, "OpenLayers.Protocol.Response",
+             "read returns a response object");
+
+        protocol.clear();
+        protocol.destroy();
+    }
+
+    function test_unfreezeFeature(t) {
+        var protocol = new OpenLayers.Protocol.SQL.Gears();
+        if (!protocol.supported()) {
+            t.plan(0);
+            return;
+        }
+
+        t.plan(10);
+
+        var feature;
+        var wkt, json, fid, state;
+
+        json = "{\"fake\":\"properties\"}";
+        fid = "1000";
+        state = OpenLayers.State.INSERT;
+
+        var row = {
+            fieldByName: function(str) {
+                if (str == "geometry") {
+                    return wkt;
+                }
+                if (str == "properties") {
+                    return json;
+                }
+                if (str == "fid") {
+                    return fid;
+                }
+                if (str == "state") {
+                    return state;
+                }
+            }
+        };
+
+        // 5 tests
+        wkt = "POINT(1 2)";
+        feature = protocol.unfreezeFeature(row);
+        t.eq(feature.CLASS_NAME, "OpenLayers.Feature.Vector",
+             "unfreezeFeature returns an OpenLayers.Feature.Vector");
+        t.ok(feature.geometry.x == 1 && feature.geometry.y == 2,
+             "unfreezeFeature returns a feature with correct geometry");
+        t.eq(feature.attributes.fake, "properties",
+             "unfreezeFeature returns a feature with correct attributes");
+        t.eq(feature.fid, fid,
+             "unfreezeFeature returns a feature with fid");
+        t.eq(feature.state, state,
+             "unfreezeFeature returns a feature with state");
+
+        // 5 tests
+        wkt = protocol.NULL_GEOMETRY;
+        state = protocol.NULL_FEATURE_STATE;
+        feature = protocol.unfreezeFeature(row);
+        t.eq(feature.CLASS_NAME, "OpenLayers.Feature.Vector",
+             "unfreezeFeature returns an OpenLayers.Feature.Vector");
+        t.eq(feature.geometry, null,
+             "unfreezeFeature returns a feature with correct geometry");
+        t.eq(feature.attributes.fake, "properties",
+             "unfreezeFeature returns a feature with correct attributes");
+        t.eq(feature.fid, fid,
+             "unfreezeFeature returns a feature with fid");
+        t.eq(feature.state, null,
+             "unfreezeFeature returns a feature with state");
+
+        protocol.clear();
+        protocol.destroy();
+    }
+
+    function test_extractFidFromField(t) {
+        var protocol = new OpenLayers.Protocol.SQL.Gears();
+        if (!protocol.supported()) {
+            t.plan(0);
+            return;
+        }
+
+        t.plan(4);
+
+        var field, fid;
+
+        // fid is a string, field is not prefixed with FID_PREFIX
+        // 1 test
+        field = "10";
+        res = protocol.extractFidFromField(field);
+        t.eq(res, "10",
+             "extractFidFromField returns expected string");
+
+        // fid is a string, field is prefixed with FID_PREFIX
+        // 1 test
+        field = protocol.FIX_PREFIX + "10";
+        res = protocol.extractFidFromField(field);
+        t.eq(res, protocol.FIX_PREFIX + "10",
+             "extractFidFromField returns expected prefixed string");
+
+        // fid is a number, field is not prefixed with FIX_PREFIX
+        // 1 test
+        protocol.typeOfFid = "number";
+        field = "10";
+        res = protocol.extractFidFromField(field);
+        t.eq(res, 10,
+             "extractFidFromField returns expected number");
+
+        // fid is a number, field is prefixed with FIX_PREFIX
+        // 1 test
+        protocol.typeOfFid = "number";
+        field = protocol.FID_PREFIX + "10";
+        res = protocol.extractFidFromField(field);
+        t.eq(res, protocol.FID_PREFIX + "10",
+             "extractFidFromField returns expected prefixed string");
+    }
+
+    function test_freezeFeature(t) {
+        var protocol = new OpenLayers.Protocol.SQL.Gears();
+        if (!protocol.supported()) {
+            t.plan(0);
+            return;
+        }
+
+        t.plan(8);
+
+        var feature, res;
+
+        // 4 tests
+        feature = new OpenLayers.Feature.Vector();
+        feature.geometry = new OpenLayers.Geometry.Point(1, 2);
+        feature.attributes.fake = "properties";
+        feature.fid = "1000";
+        feature.state = OpenLayers.State.INSERT;
+        res = protocol.freezeFeature(feature);
+        t.eq(res[0], feature.fid,
+             "freezeFeature returns correct fid");
+        t.eq(res[1], "POINT(1 2)",
+             "freezeFeature returns correct WKT");
+        t.eq(res[2], "{\"fake\":\"properties\"}",
+             "freezeFeature returns correct JSON");
+        t.eq(res[3], feature.state,
+             "freezeFeature returns correct feature state");
+
+        // 4 tests
+        protocol.saveFeatureState = false;
+        feature = new OpenLayers.Feature.Vector();
+        feature.attributes.fake = "properties";
+        feature.fid = "1000";
+        feature.state = OpenLayers.State.INSERT;
+        res = protocol.freezeFeature(feature);
+        t.eq(res[0], feature.fid,
+             "freezeFeature returns correct fid");
+        t.eq(res[1], protocol.NULL_GEOMETRY,
+             "freezeFeature returns expected null geom string");
+        t.eq(res[2], "{\"fake\":\"properties\"}",
+             "freezeFeature returns correct JSON");
+        t.eq(res[3], protocol.NULL_FEATURE_STATE,
+             "freezeFeature returns expected null feature state string");
+
+        protocol.clear();
+        protocol.destroy();
+     }
+
+     function test_create(t) {
+        var protocol = new OpenLayers.Protocol.SQL.Gears();
+        if (!protocol.supported()) {
+            t.plan(0);
+            return;
+        }
+
+        t.plan(8);
+
+        var resp;
+        var scope = {"fake": "scope"};
+
+        var options = {
+            callback: function(resp) {
+                t.eq(resp.CLASS_NAME, "OpenLayers.Protocol.Response",
+                     "user callback is passed a response");
+                t.eq(resp.requestType, "create",
+                     "user callback is passed correct request type in resp");
+                t.ok(this == scope,
+                     "user callback called with correct scope");
+            },
+            scope: scope
+        };
+
+        // 4 tests
+        var feature = new OpenLayers.Feature.Vector();
+        feature.fid = "1000";
+        feature.attributes.fake = "properties";
+        feature.state = OpenLayers.State.INSERT;
+        resp = protocol.create([feature], options);
+        t.eq(resp.CLASS_NAME, "OpenLayers.Protocol.Response",
+             "create returns a response");
+
+        // check what we have in the DB
+        // 4 tests
+        resp = protocol.read({"noFeatureStateReset": true});
+        t.eq(resp.features.length, 1,
+             "create inserts feature in the DB");
+        t.eq(resp.features[0].fid, feature.fid,
+             "create inserts feature with correct fid");
+        t.eq(resp.features[0].attributes.fake, feature.attributes.fake,
+             "create inserts feature with correct attributes");
+        t.eq(resp.features[0].state, feature.state,
+             "create inserts feature with correct state");
+
+        protocol.clear();
+        protocol.destroy();
+    }
+
+     function test_createOrUpdate(t) {
+        var protocol = new OpenLayers.Protocol.SQL.Gears();
+        if (!protocol.supported()) {
+            t.plan(0);
+            return;
+        }
+
+        t.plan(5);
+
+        // 1 test
+        var feature = new OpenLayers.Feature.Vector();
+        feature.fid = "1000";
+        feature.attributes.fake = "properties";
+        feature.state = OpenLayers.State.INSERT;
+        resp = protocol.createOrUpdate([feature]);
+        t.eq(resp.CLASS_NAME, "OpenLayers.Protocol.Response",
+             "createOrUpdate returns a response");
+
+        // check what we have in the DB
+        // 4 tests
+        resp = protocol.read({"noFeatureStateReset": true});
+        t.eq(resp.features.length, 1,
+             "createOrUpdate inserts feature in the DB");
+        t.eq(resp.features[0].fid, feature.fid,
+             "createOrUpdate inserts feature with correct fid");
+        t.eq(resp.features[0].attributes.fake, feature.attributes.fake,
+             "createOrUpdate inserts feature with correct attributes");
+        t.eq(resp.features[0].state, feature.state,
+             "createOrUpdate inserts feature with correct state");
+
+        protocol.clear();
+        protocol.destroy();
+    }
+
+    function test_delete(t) {
+        var protocol = new OpenLayers.Protocol.SQL.Gears();
+        if (!protocol.supported()) {
+            t.plan(0);
+            return;
+        }
+
+        t.plan(4);
+
+        function createOneAndDeleteOne(fid, deleteOptions) {
+            var feature = new OpenLayers.Feature.Vector();
+            feature.fid = fid;
+            feature.attributes.fake = "properties";
+            feature.state = OpenLayers.State.INSERT;
+            var r = protocol.create([feature]);
+            protocol["delete"](r.reqFeatures, deleteOptions);
+        }
+
+        var resp, fid;
+
+        // 1 test
+        fid = 1000;
+        protocol.saveFeatureState = false;
+        createOneAndDeleteOne(fid)
+        resp = protocol.read();
+        t.eq(resp.features.length, 0,
+             "delete deletes feature if saveFeatureState is false");
+        protocol.clear();
+
+        // 1 test
+        fid = 1000;
+        protocol.saveFeatureState = true;
+        createOneAndDeleteOne(fid);
+        resp = protocol.read();
+        t.eq(resp.features.length, 1,
+             "delete does not delete feature if saveFeatureState is true");
+        protocol.clear();
+
+        // 1 test
+        fid = "1000";
+        protocol.saveFeatureState = true;
+        createOneAndDeleteOne(fid);
+        resp = protocol.read();
+        t.eq(resp.features.length, 1,
+             "delete does not delete feature if saveFeatureState is true");
+        protocol.clear();
+
+        // 1 test
+        fid = protocol.FID_PREFIX + "1000";
+        protocol.saveFeatureState = true;
+        createOneAndDeleteOne(fid, {dontDelete: true});
+        resp = protocol.read();
+        t.eq(resp.features.length, 0,
+             "delete deletes feature if saveFeatureState is true and fid is prefixed");
+        protocol.clear();
+
+        protocol.destroy();
+    }
+
+    function test_callUserCallback(t) {
+        var protocol = new OpenLayers.Protocol.SQL.Gears();
+        if (!protocol.supported()) {
+            t.plan(0);
+            return;
+        }
+
+        t.plan(6);
+
+        var options, resp;
+        var scope = {'fake': 'scope'};
+
+        // test commit callback
+        // 1 tests
+        options = {
+            'callback': function() {
+                t.ok(this == scope, 'callback called with correct scope');
+            },
+            'scope': scope
+        };
+        resp = {'requestType': 'create', 'last': true};
+        protocol.callUserCallback(options, resp);
+        // 0 test
+        resp = {'requestType': 'create', 'last': false};
+        protocol.callUserCallback(options, resp);
+
+        // test create callback
+        // 2 tests
+        options = {
+            'create': {
+                'callback': function(r) {
+                    t.ok(this == scope, 'callback called with correct scope');
+                    t.ok(r == resp, 'callback called with correct response');
+                },
+                'scope': scope
+            }
+        };
+        resp = {'requestType': 'create'};
+        protocol.callUserCallback(options, resp);
+
+        // test with both callbacks set
+        // 3 tests
+        options = {
+            'create': {
+                'callback': function(r) {
+                    t.ok(this == scope, 'callback called with correct scope');
+                    t.ok(r == resp, 'callback called with correct response');
+                },
+                'scope': scope
+            },
+            'callback': function() {
+                t.ok(this == scope, 'callback called with correct scope');
+            },
+            'scope': scope
+        };
+        resp = {'requestType': 'create', 'last': true};
+        protocol.callUserCallback(options, resp);
+
+        // no callback set
+        // 0 test
+        options = {
+            'delete': {
+                'callback': function(resp) {
+                    t.fail('callback should not get called');
+                }
+            }
+        };
+        resp = {'requestType': 'create'};
+        protocol.callUserCallback(options, resp);
+
+        // cleanup
+        protocol.destroy();
+    }
+
+  </script>
+</head>
+<body>
+</body>
+</html>
diff --git a/tests/Renderer/Elements.html b/tests/Renderer/Elements.html
index 75d07715b7..e58ccdb72b 100644
--- a/tests/Renderer/Elements.html
+++ b/tests/Renderer/Elements.html
@@ -428,7 +428,8 @@
                 'removeChild': function(elem) {
                     gElemRemoved = elem;
                 }
-            }
+            },
+            '_style' : {backgroundGraphic: "foo"}
         };
         gBackElement = {
             'parentNode': {
diff --git a/tests/Request.html b/tests/Request.html
index 28484d2406..b1807e21f7 100644
--- a/tests/Request.html
+++ b/tests/Request.html
@@ -20,7 +20,7 @@
     function test_issue(t) {
         setup();
 
-        t.plan(19);
+        t.plan(22);
         var request, config;
         var proto = OpenLayers.Request.XMLHttpRequest.prototype;
         var issue = OpenLayers.Function.bind(OpenLayers.Request.issue,
@@ -46,8 +46,43 @@
             t.eq(async, config.async, "open called with correct async");
             t.eq(user, config.user, "open called with correct user");
             t.eq(password, config.password, "open called with correct password");
+        };
+        request = issue(config);
+        
+        // test that params are serialized as query string - 1 test
+        config = {
+            method: "GET",
+            url: "http://example.com/",
+            params: {"foo": "bar"}
+        };
+        proto.open = function(method, url, async, user, password) {
+            t.eq(url, config.url + "?foo=bar", "params serialized as query string");
+        };
+        request = issue(config);
+        
+        // test that empty params object doesn't produce query string - 1 test
+        config = {
+            method: "GET",
+            url: "http://example.com/",
+            params: {}
+        };
+        proto.open = function(method, url, async, user, password) {
+            t.eq(url, config.url, "empty params doesn't produce query string");
         }
         request = issue(config);
+        
+        // test that query string doesn't get two ? separators
+        config = {
+            method: "GET",
+            url: "http://example.com/?existing=query",
+            params: {"foo": "bar"}
+        };
+        proto.open = function(method, url, async, user, password) {
+            t.eq(url, config.url + "&foo=bar", "existing query string gets extended with &");
+        }
+        request = issue(config);
+
+        // reset open method
         proto.open = _open;
         
         // test that headers are correctly set - 4 tests
diff --git a/tests/Strategy/BBOX.html b/tests/Strategy/BBOX.html
new file mode 100644
index 0000000000..bb019de260
--- /dev/null
+++ b/tests/Strategy/BBOX.html
@@ -0,0 +1,166 @@
+<html>
+<head>
+  <script src="../../lib/OpenLayers.js"></script>
+  <script type="text/javascript">
+
+    function test_initialize(t) {
+        t.plan(1);
+
+        var ratio = 4;
+
+        var s = new OpenLayers.Strategy.BBOX({ratio: ratio});
+        t.eq(s.ratio, ratio, "ctor sets ratio");
+    }
+
+    function test_activate(t) {
+        t.plan(5);
+
+        var l = new OpenLayers.Layer.Vector();
+        var s = new OpenLayers.Strategy.BBOX();
+        s.setLayer(l);
+
+        t.eq(s.active, false, "not active after construction");
+
+        var activated = s.activate();
+        t.eq(activated, true, "activate returns true");
+        t.eq(s.active, true, "activated after activate");
+        t.ok(l.events.listeners["moveend"][0].obj == s &&
+             l.events.listeners["moveend"][0].func == s.update,
+             "activates registers moveend listener");
+        t.ok(l.events.listeners["refresh"][0].obj == s &&
+             l.events.listeners["refresh"][0].func == s.update,
+             "activates registers refresh listener");
+    }
+
+    function test_update(t) {
+        t.plan(6);
+
+        var s = new OpenLayers.Strategy.BBOX();
+
+        var invalidBoundsReturnValue;
+        var bounds = new OpenLayers.Bounds(-100, -40, 100, 40);
+
+        s.invalidBounds = function(b) {
+            t.ok(b == bounds,
+                 "update calls invalidBounds with correct arg");
+            return invalidBoundsReturnValue;
+        };
+        s.calculateBounds = function(b) {
+            t.ok(b == bounds,
+                 "update calls calculateBounds with correct arg");
+        };
+        s.triggerRead = function() {
+            t.ok(true,
+                 "update calls triggerRead");
+        };
+
+        s.setLayer({
+            map: {
+                getExtent: function() {
+                    return bounds;
+                }
+            }
+        });
+
+        // 2 tests
+        invalidBoundsReturnValue = true;
+        s.update({force: true});
+
+        // 3 tests
+        invalidBoundsReturnValue = true;
+        s.update();
+
+        // 1 tests
+        invalidBoundsReturnValue = false;
+        s.update();
+    }
+
+    function test_triggerRead(t) {
+        t.plan(7);
+
+        var s = new OpenLayers.Strategy.BBOX();
+
+        var filter = {"fake": "filter"};
+
+        s.createFilter = function() {
+            return filter;
+        };
+
+        s.setLayer({
+            protocol: {
+                read: function(options) {
+                    t.ok(options.filter == filter,
+                         "protocol read called with correct filter");
+                    t.ok(options.callback == s.merge,
+                         "protocol read called with correct callback");
+                    t.ok(options.scope == s,
+                         "protocol read called with correct scope");
+                }
+            }
+        });
+
+        // 3 tests
+        s.triggerRead();
+
+        // 4 tests
+        s.response = {
+            priv: {
+                abort: function() {
+                    t.ok(true,
+                         "triggerRead aborts previous read request");
+                }
+            }
+        };
+        s.triggerRead();
+    }
+
+    function test_createFilter(t) {
+        t.plan(3);
+
+        var s = new OpenLayers.Strategy.BBOX();
+
+        var f;
+
+        // 2 test
+        s.setLayer({});
+        f = s.createFilter();
+        t.ok(f.CLASS_NAME.search(/^OpenLayers.Filter.Spatial/) != -1,
+             "createFilter returns a spatial filter object");
+        t.eq(f.type, OpenLayers.Filter.Spatial.BBOX,
+             "createFilter returns a BBOX-typed filter");
+
+        // 1 test
+        s.setLayer({filter: {fake: "filter"}});
+        f = s.createFilter();
+        t.ok(f.CLASS_NAME.search(/^OpenLayers.Filter.Logical/) != -1,
+             "createFilter returns a logical filter object");
+    }
+
+    function test_merge(t) {
+        t.plan(2);
+
+        var s = new OpenLayers.Strategy.BBOX();
+
+        var features = ["fake", "feature", "array"];
+
+        s.setLayer({
+           destroyFeatures: function() {
+               t.ok(true,
+                    "merge calls destroyFeatures");
+           },
+           addFeatures: function(f) {
+               t.ok(f == features,
+                    "merge calls addFeatures with the correct features");
+           }
+        });
+
+        // 2 tests
+        s.merge({features: features});
+    }
+
+  </script>
+</head>
+<body>
+    <div id="map" style="width: 400px; height: 200px" />
+</body>
+</html>
diff --git a/tests/Strategy/Cluster.html b/tests/Strategy/Cluster.html
new file mode 100644
index 0000000000..7dd0fa6088
--- /dev/null
+++ b/tests/Strategy/Cluster.html
@@ -0,0 +1,108 @@
+<html>
+<head>
+  <script src="../../lib/OpenLayers.js"></script>
+  <script type="text/javascript">
+
+    function test_activate(t) {
+        t.plan(2);
+
+        var strategy = new OpenLayers.Strategy.Cluster();
+        t.eq(strategy.active, false, "not active after construction");
+
+        var layer = new OpenLayers.Layer.Vector("Vector Layer", {
+            strategies: [strategy]
+        });
+        var map = new OpenLayers.Map('map');
+        map.addLayer(layer);
+        
+        t.eq(strategy.active, true, "active after adding to map");
+    }
+
+    function test_clusters(t) {
+        t.plan(10);
+
+        function featuresEq(got, exp) {
+            var eq = false;
+            if(got instanceof Array && exp instanceof Array) {
+                if(got.length === exp.length) {
+                    for(var i=0; i<got.length; ++i) {
+                        if(got[i] !== exp[i]) {
+                            console.log(got[i], exp[i]);
+                            break;
+                        }
+                    }
+                    eq = (i == got.length);
+                }
+            }
+            return eq;
+        }
+
+        var strategy = new OpenLayers.Strategy.Cluster();
+        var layer = new OpenLayers.Layer.Vector("Vector Layer", {
+            strategies: [strategy],
+            isBaseLayer: true
+        });
+        var map = new OpenLayers.Map('map', {
+            resolutions: [4, 2, 1],
+            maxExtent: new OpenLayers.Bounds(-40, -40, 40, 40)
+        });
+        map.addLayer(layer);
+        
+        // create features in a line, 1 unit apart
+        var features = new Array(80);
+        for(var i=0; i<80; ++i) {
+            features[i] = new OpenLayers.Feature.Vector(
+                new OpenLayers.Geometry.Point(-40 + i, 0)
+            );
+        }
+        
+        map.setCenter(new OpenLayers.LonLat(0, 0), 0);
+        layer.addFeatures(features);
+        
+        // resolution 4
+        // threshold: 4 * 20 = 80 units
+        // one cluster
+        t.eq(layer.features.length, 1, "[4] layer has one cluster");
+        t.ok(featuresEq(layer.features[0].cluster, features), "[4] cluster includes all features");
+        
+        // resolution 2
+        // threshold: 2 * 20 = 40 units
+        // two clusters (41 and 39) - first cluster includes all features within 40 units of the first (0-40 or 41 features)
+        map.zoomIn();
+        t.eq(layer.features.length, 2, "[2] layer has two clusters");
+        t.ok(featuresEq(layer.features[0].cluster, features.slice(0, 41)), "[2] first cluster includes first 41 features");
+        t.ok(featuresEq(layer.features[1].cluster, features.slice(41, 80)), "[2] second cluster includes last 39 features");
+        
+        // resolution 1
+        // threshold: 1 * 20 = 20 units
+        // four clusters (21, 21, 21, and 17)
+        map.zoomIn();
+        t.eq(layer.features.length, 4, "[1] layer has four clusters");
+        t.ok(featuresEq(layer.features[0].cluster, features.slice(0, 21)), "[1] first cluster includes first 21 features");
+        t.ok(featuresEq(layer.features[1].cluster, features.slice(21, 42)), "[2] second cluster includes second 21 features");
+        t.ok(featuresEq(layer.features[2].cluster, features.slice(42, 63)), "[2] third cluster includes third 21 features");
+        t.ok(featuresEq(layer.features[3].cluster, features.slice(63, 80)), "[2] fourth cluster includes last 17 features");
+    }
+
+    function test_deactivate(t) {
+        t.plan(2);
+
+        var strategy = new OpenLayers.Strategy.Cluster();
+        var layer = new OpenLayers.Layer.Vector("Vector Layer", {
+            strategies: [strategy]
+        });
+        var map = new OpenLayers.Map('map');
+        map.addLayer(layer);
+        
+        t.eq(strategy.active, true, "active after adding to map");
+        
+        map.removeLayer(layer);
+        t.eq(strategy.active, false, "not active after removing from map");
+    }
+
+  </script>
+</head>
+<body>
+    <div id="map" style="width: 400px; height: 200px" />
+</body>
+</html>
diff --git a/tests/Strategy/Paging.html b/tests/Strategy/Paging.html
new file mode 100644
index 0000000000..221cd5c86a
--- /dev/null
+++ b/tests/Strategy/Paging.html
@@ -0,0 +1,113 @@
+<html>
+<head>
+  <script src="../../lib/OpenLayers.js"></script>
+  <script type="text/javascript">
+
+    function test_activate(t) {
+        t.plan(2);
+
+        var strategy = new OpenLayers.Strategy.Paging();
+        t.eq(strategy.active, false, "not active after construction");
+
+        var layer = new OpenLayers.Layer.Vector("Vector Layer", {
+            strategies: [strategy]
+        });
+        var map = new OpenLayers.Map('map');
+        map.addLayer(layer);
+        
+        t.eq(strategy.active, true, "active after adding to map");
+    }
+    
+    function test_paging(t) {
+        t.plan(18);
+
+        var strategy = new OpenLayers.Strategy.Paging();
+        var layer = new OpenLayers.Layer.Vector("Vector Layer", {
+            strategies: [strategy],
+            drawFeature: function() {}
+        });
+        var map = new OpenLayers.Map('map');
+        map.addLayer(layer);
+        
+        var features = new Array(25);
+        for(var i=0; i<features.length; ++i) {
+            features[i] = {destroy: function() {}};
+        }
+        
+        function featuresEq(got, exp) {
+            var eq = false;
+            if(got instanceof Array && exp instanceof Array) {
+                if(got.length === exp.length) {
+                    for(var i=0; i<got.length; ++i) {
+                        if(got[i] !== exp[i]) {
+                            console.log(got[i], exp[i]);
+                            break;
+                        }
+                    }
+                    eq = (i == got.length);
+                }
+            }
+            return eq;
+        }
+        
+        var len = strategy.pageLength();
+        t.eq(len, 10, "page length defaults to 10");
+        
+        // add 25 features to the layer
+        layer.addFeatures(features);
+        t.eq(strategy.features.length, features.length, "strategy caches all features");
+        t.eq(layer.features.length, len, "layer gets one page of features");
+        t.ok(featuresEq(layer.features, features.slice(0, len)), "layer gets first page initially");
+        t.eq(strategy.pageNum(), 0, "strategy reports 0 based page number");
+        t.eq(strategy.pageCount(), Math.ceil(features.length / len), "strategy reports correct number of pages");
+        
+        // load next page of features
+        var changed = strategy.pageNext();
+        t.eq(changed, true, "(1) strategy reports change");
+        t.eq(strategy.pageNum(), 1, "second page");
+        t.ok(featuresEq(layer.features, features.slice(len, 2*len)), "layer has second page of features");
+        
+        // load next page of features (half page)
+        changed = strategy.pageNext();
+        t.eq(changed, true, "(2) strategy reports change");
+        t.eq(strategy.pageNum(), 2, "third page");
+        
+        // try to change forward again
+        changed = strategy.pageNext();
+        t.eq(changed, false, "strategy reports no change");
+        t.eq(layer.features.length, features.length % len, "layer has partial page");
+        t.ok(featuresEq(layer.features, features.slice(2*len, 3*len)), "layer has third page of features");
+        t.eq(strategy.pageNum(), 2, "still on third page");
+        
+        // change back a page
+        changed = strategy.pagePrevious();
+        t.eq(changed, true, "(3) strategy reports change");
+        t.eq(strategy.pageNum(), 1, "back on second page");
+        t.ok(featuresEq(layer.features, features.slice(len, 2*len)), "layer has second page of features again");
+        
+        layer.destroy();
+        
+    }
+
+    function test_deactivate(t) {
+        t.plan(2);
+
+        var strategy = new OpenLayers.Strategy.Paging();
+        var layer = new OpenLayers.Layer.Vector("Vector Layer", {
+            strategies: [strategy]
+        });
+        var map = new OpenLayers.Map('map');
+        map.addLayer(layer);
+        
+        t.eq(strategy.active, true, "active after adding to map");
+        
+        map.removeLayer(layer);
+        t.eq(strategy.active, false, "not active after removing from map");
+    }
+
+  </script>
+</head>
+<body>
+    <div id="map" style="width: 400px; height: 200px" />
+</body>
+</html>
diff --git a/tests/geom_eq.js b/tests/geom_eq.js
new file mode 100644
index 0000000000..26f3a95034
--- /dev/null
+++ b/tests/geom_eq.js
@@ -0,0 +1,110 @@
+/**
+ * File: xml_eq.js
+ * Adds a xml_eq method to AnotherWay test objects.
+ *
+ */
+
+(function() {
+    
+    /**
+     * Function assertEqual
+     * Test two objects for equivalence (based on ==).  Throw an exception
+     *     if not equivalent.
+     * 
+     * Parameters:
+     * got - {Object}
+     * expected - {Object}
+     * msg - {String} The message to be thrown.  This message will be appended
+     *     with ": got {got} but expected {expected}" where got and expected are
+     *     replaced with string representations of the above arguments.
+     */
+    function assertEqual(got, expected, msg) {
+        if(got === undefined) {
+            got = "undefined";
+        } else if (got === null) {
+            got = "null";
+        }
+        if(expected === undefined) {
+            expected = "undefined";
+        } else if (expected === null) {
+            expected = "null";
+        }
+        if(got != expected) {
+            throw msg + ": got '" + got + "' but expected '" + expected + "'";
+        }
+    }
+    
+    /**
+     * Function assertGeometryEqual
+     * Test two geometries for equivalence.  Geometries are considered
+     *     equivalent if they are of the same class, and given component
+     *     geometries, if all components are equivalent. Throws a message as
+     *     exception if not equivalent.
+     * 
+     * Parameters:
+     * got - {OpenLayers.Geometry}
+     * expected - {OpenLayers.Geometry}
+     * options - {Object} Optional object for configuring test options.
+     */
+    function assertGeometryEqual(got, expected, options) {
+        
+        var OpenLayers = Test.AnotherWay._g_test_iframe.OpenLayers;
+
+        // compare types
+        assertEqual(typeof got, typeof expected, "Object types mismatch");
+        
+        // compare classes
+        assertEqual(got.CLASS_NAME, expected.CLASS_NAME, "Object class mismatch");
+        
+        if(got instanceof OpenLayers.Geometry.Point) {
+            // compare points
+            assertEqual(got.x, expected.x, "x mismatch");
+            assertEqual(got.y, expected.y, "y mismatch");
+            assertEqual(got.z, expected.z, "z mismatch");
+        } else {
+            // compare components
+            assertEqual(
+                got.components.length, expected.components.length,
+                "Component length mismatch for " + got.CLASS_NAME
+            );
+            for(var i=0; i<got.components.length; ++i) {
+                try {
+                    assertGeometryEqual(
+                        got.components[i], expected.components[i], options
+                    );
+                } catch(err) {
+                    throw "Bad component " + i + " for " + got.CLASS_NAME + ": " + err;
+                }
+            }
+        }
+        return true;
+    }
+    
+    /**
+     * Function: Test.AnotherWay._test_object_t.geom_eq
+     * Test if two geometry objects are equivalent.  Tests for same geometry
+     *     class, same number of components (if any), equivalent component
+     *     geometries, and same coordinates.
+     *
+     * (code)
+     * t.geom_eq(got, expected, message);
+     * (end)
+     * 
+     * Parameters:
+     * got - {OpenLayers.Geometry} Any geometry instance.
+     * expected - {OpenLayers.Geometry} The expected geometry.
+     * msg - {String} A message to print with test output.
+     * options - {Object} Optional object for configuring test options.
+     */
+    var proto = Test.AnotherWay._test_object_t.prototype;
+    proto.geom_eq = function(got, expected, msg, options) {        
+        // test geometries for equivalence
+        try {
+            assertGeometryEqual(got, expected, options);
+            this.ok(true, msg);
+        } catch(err) {
+            this.fail(msg + ": " + err);
+        }
+    }
+    
+})();
\ No newline at end of file
diff --git a/tests/list-tests.html b/tests/list-tests.html
index 68cb559996..f237c6647d 100644
--- a/tests/list-tests.html
+++ b/tests/list-tests.html
@@ -43,6 +43,8 @@
     <li>Format/GeoJSON.html</li>
     <li>Format/GeoRSS.html</li>
     <li>Format/GML.html</li>
+    <li>Format/GML/v2.html</li>
+    <li>Format/GML/v3.html</li>
     <li>Format/GPX.html</li>
     <li>Format/JSON.html</li>
     <li>Format/KML.html</li>
@@ -115,6 +117,8 @@
     <li>Projection.html</li>
     <li>Protocol.html</li>
     <li>Protocol/HTTP.html</li>
+    <li>Protocol/SQL.html</li>
+    <li>Protocol/SQL/Gears.html</li>
     <li>Renderer.html</li>
     <li>Renderer/Canvas.html</li>
     <li>Renderer/Elements.html</li>
@@ -124,7 +128,10 @@
     <li>Request/XMLHttpRequest.html</li>
     <li>Rule.html</li>
     <li>Strategy.html</li>
+    <li>Strategy/Cluster.html</li>
     <li>Strategy/Fixed.html</li>
+    <li>Strategy/Paging.html</li>
+    <li>Strategy/BBOX.html</li>
     <li>Style.html</li>
     <li>StyleMap.html</li>
     <li>Tile.html</li>
diff --git a/tests/run-tests.html b/tests/run-tests.html
index 46bea5d640..13c350b5ec 100644
--- a/tests/run-tests.html
+++ b/tests/run-tests.html
@@ -2307,6 +2307,7 @@ onload=function()
 // -->
 </script>
 <script type="text/javascript" src="xml_eq.js"></script>
+<script type="text/javascript" src="geom_eq.js"></script>
 </head><body>
 
 <div id="col1">
diff --git a/tests/xml_eq.js b/tests/xml_eq.js
index c330979945..47084cd858 100644
--- a/tests/xml_eq.js
+++ b/tests/xml_eq.js
@@ -97,10 +97,13 @@
      * Parameters:
      * got - {DOMElement}
      * expected - {DOMElement}
-     * options - {Object} Optional object for configuring test options.  Set
-     *     'prefix' property to true in order to compare element and attribute
-     *     prefixes (namespace uri always tested).  By default, prefixes
-     *     are not tested.
+     * options - {Object} Optional object for configuring test options.
+     *
+     * Valid options:
+     * prefix - {Boolean} Compare element and attribute
+     *     prefixes (namespace uri always tested).  Default is false.
+     * includeWhiteSpace - {Boolean} Include whitespace only nodes when
+     *     comparing child nodes.  Default is false.
      */
     function assertElementNodesEqual(got, expected, options) {
         var testPrefix = (options && options.prefix === true);
@@ -190,14 +193,17 @@
             }
             
             // compare children
+            var gotChildNodes = getChildNodes(got, options);
+            var expChildNodes = getChildNodes(expected, options);
+
             assertEqual(
-                got.childNodes.length, expected.childNodes.length,
+                gotChildNodes.length, expChildNodes.length,
                 "Children length mismatch for " + got.nodeName
             );
-            for(var j=0; j<got.childNodes.length; ++j) {
+            for(var j=0; j<gotChildNodes.length; ++j) {
                 try {
                     assertElementNodesEqual(
-                        got.childNodes[j], expected.childNodes[j]
+                        gotChildNodes[j], expChildNodes[j], options
                     );
                 } catch(err) {
                     throw "Bad child " + j + " for element " + got.nodeName + ": " + err;
@@ -206,6 +212,50 @@
         }
         return true;
     }
+
+    /**
+     * Function getChildNodes
+     * Returns the child nodes of the specified nodes. By default this method
+     *     will ignore child text nodes which are made up of whitespace content.
+     *     The 'includeWhiteSpace' option is used to control this behaviour.
+     * 
+     * Parameters:
+     * node - {DOMElement}
+     * options - {Object} Optional object for test configuration.
+     * 
+     * Valid options:
+     * includeWhiteSpace - {Boolean} Include whitespace only nodes when
+     *     comparing child nodes.  Default is false.
+     * 
+     * Returns:
+     * {Array} of {DOMElement}
+     */
+    function getChildNodes(node, options) {
+        //check whitespace
+        if (options && options.includeWhiteSpace) {
+            return node.childNodes;
+        }
+        else {
+           nodes = [];
+           for (var i = 0; i < node.childNodes.length; i++ ) {
+              var child = node.childNodes[i];
+              if (child.nodeType == 1) {
+                 //element node, add it 
+                 nodes.push(child);
+              }
+              else if (child.nodeType == 3) {
+                 //text node, add if non empty
+                 if (child.nodeValue && 
+                       child.nodeValue.replace(/^\s*(.*?)\s*$/, "$1") != "" ) { 
+
+                    nodes.push(child);
+                 }
+              }
+           }
+  
+           return nodes;
+        }
+    } 
     
     /**
      * Function: Test.AnotherWay._test_object_t.xml_eq
@@ -221,10 +271,13 @@
      * got - {DOMElement | String} A DOM node or XML string to test.
      * expected - {DOMElement | String} The expected DOM node or XML string.
      * msg - {String} A message to print with test output.
-     * options - {Object} Optional object for configuring test options.  Set
-     *     'prefix' property to true in order to compare element and attribute
-     *     prefixes (namespace uri always tested).  By default, prefixes
-     *     are not tested.
+     * options - {Object} Optional object for configuring test.
+     *
+     * Valid options:
+     * prefix - {Boolean} Compare element and attribute
+     *     prefixes (namespace uri always tested).  Default is false.
+     * includeWhiteSpace - {Boolean} Include whitespace only nodes when
+     *     comparing child nodes.  Default is false.
      */
     var proto = Test.AnotherWay._test_object_t.prototype;
     proto.xml_eq = function(got, expected, msg, options) {
@@ -255,4 +308,4 @@
         }
     }
     
-})();
\ No newline at end of file
+})();