From f96319e6f64ed690e2a8d2b2630c64d362a64657 Mon Sep 17 00:00:00 2001
From: Pierre-Yves Gerardy <py@py.gy>
Date: Sun, 19 Feb 2017 00:33:01 +0100
Subject: [PATCH] Tests: add dummy forEach blocks around sections with
 components

---
 api/tests/test-mount.js             |  451 ++++-----
 render/tests/test-component.js      | 1335 ++++++++++++++-------------
 render/tests/test-onbeforeremove.js |   68 +-
 render/tests/test-onbeforeupdate.js |  336 +++----
 render/tests/test-onremove.js       |   72 +-
 render/tests/test-updateNodes.js    |   66 +-
 tests/test-api.js                   |  163 ++--
 7 files changed, 1268 insertions(+), 1223 deletions(-)

diff --git a/api/tests/test-mount.js b/api/tests/test-mount.js
index 5afd9c39..86ae3835 100644
--- a/api/tests/test-mount.js
+++ b/api/tests/test-mount.js
@@ -1,6 +1,7 @@
 "use strict"
 
 var o = require("../../ospec/ospec")
+var components = require("../../test-utils/components")
 var domMock = require("../../test-utils/domMock")
 
 var m = require("../../render/hyperscript")
@@ -32,237 +33,243 @@ o.spec("mount", function() {
 		o(threw).equals(true)
 	})
 
-	o("throws on invalid `root` DOM node", function() {
-		var threw = false
-		try {
-			mount(null, {view: function() {}})
-		} catch (e) {
-			threw = true
-		}
-		o(threw).equals(true)
-	})
+	;[components[0]].forEach(function(cmp){
+		o.spec(cmp.kind, function(){
+			var createComponent = cmp.create
 
-	o("renders into `root` (POJO component)", function() {
-		mount(root, {
-			view : function() {
-				return m("div")
-			}
-		})
-
-		o(root.firstChild.nodeName).equals("DIV")
-	})
-
-	o("renders into `root` (class component)", function() {
-		function Cmp(){}
-		Cmp.prototype.view = function(){return m("div")}
-		mount(root, Cmp)
-
-		o(root.firstChild.nodeName).equals("DIV")
-	})
-
-	o("renders into `root` (closure component)", function() {
-		mount(root, function(){
-			return {
-				view : function() {
-					return m("div")
+			o("throws on invalid `root` DOM node", function() {
+				var threw = false
+				try {
+					mount(null, {view: function() {}})
+				} catch (e) {
+					threw = true
 				}
-			}
-		})
+				o(threw).equals(true)
+			})
 
-		o(root.firstChild.nodeName).equals("DIV")
-	})
-
-	o("mounting null unmounts", function() {
-		mount(root, {
-			view : function() {
-				return m("div")
-			}
-		})
-
-		mount(root, null)
-
-		o(root.childNodes.length).equals(0)
-	})
-
-	o("redraws on events", function(done) {
-		var onupdate = o.spy()
-		var oninit   = o.spy()
-		var onclick  = o.spy()
-		var e = $window.document.createEvent("MouseEvents")
-
-		e.initEvent("click", true, true)
-
-		mount(root, {
-			view : function() {
-				return m("div", {
-					oninit   : oninit,
-					onupdate : onupdate,
-					onclick  : onclick,
-				})
-			}
-		})
-
-		root.firstChild.dispatchEvent(e)
-
-		o(oninit.callCount).equals(1)
-		o(onupdate.callCount).equals(0)
-
-		o(onclick.callCount).equals(1)
-		o(onclick.this).equals(root.firstChild)
-		o(onclick.args[0].type).equals("click")
-		o(onclick.args[0].target).equals(root.firstChild)
-
-		// Wrapped to give time for the rate-limited redraw to fire
-		setTimeout(function() {
-			o(onupdate.callCount).equals(1)
-
-			done()
-		}, FRAME_BUDGET)
-	})
-
-	o("redraws several mount points on events", function(done, timeout) {
-		timeout(60)
-		
-		var onupdate0 = o.spy()
-		var oninit0   = o.spy()
-		var onclick0  = o.spy()
-		var onupdate1 = o.spy()
-		var oninit1   = o.spy()
-		var onclick1  = o.spy()
-
-		var e = $window.document.createEvent("MouseEvents")
-
-		e.initEvent("click", true, true)
-
-		render(root, [
-			m("#child0"),
-			m("#child1")
-		])
-
-		mount(root.childNodes[0], {
-			view : function() {
-				return m("div", {
-					oninit   : oninit0,
-					onupdate : onupdate0,
-					onclick  : onclick0,
-				})
-			}
-		})
-
-		o(oninit0.callCount).equals(1)
-		o(onupdate0.callCount).equals(0)
-
-		mount(root.childNodes[1], {
-			view : function() {
-				return m("div", {
-					oninit   : oninit1,
-					onupdate : onupdate1,
-					onclick  : onclick1,
-				})
-			}
-		})
-
-		o(oninit1.callCount).equals(1)
-		o(onupdate1.callCount).equals(0)
-
-		root.childNodes[0].firstChild.dispatchEvent(e)
-		o(onclick0.callCount).equals(1)
-		o(onclick0.this).equals(root.childNodes[0].firstChild)
-
-		setTimeout(function() {
-			o(onupdate0.callCount).equals(1)
-			o(onupdate1.callCount).equals(1)
-
-			root.childNodes[1].firstChild.dispatchEvent(e)
-			o(onclick1.callCount).equals(1)
-			o(onclick1.this).equals(root.childNodes[1].firstChild)
-
-			setTimeout(function() {
-				o(onupdate0.callCount).equals(2)
-				o(onupdate1.callCount).equals(2)
-
-				done()
-			}, FRAME_BUDGET)
-		}, FRAME_BUDGET)
-
-	})
-
-	o("event handlers can skip redraw", function(done) {
-		var onupdate = o.spy()
-		var oninit = o.spy()
-		var e = $window.document.createEvent("MouseEvents")
-
-		e.initEvent("click", true, true)
-
-		mount(root, {
-			view: function() {
-				return m("div", {
-					oninit: oninit,
-					onupdate: onupdate,
-					onclick: function(e) {
-						e.redraw = false
+			o("renders into `root` (POJO component)", function() {
+				mount(root, {
+					view : function() {
+						return m("div")
 					}
 				})
-			}
-		})
 
-		root.firstChild.dispatchEvent(e)
+				o(root.firstChild.nodeName).equals("DIV")
+			})
 
-		o(oninit.callCount).equals(1)
+			o("renders into `root` (class component)", function() {
+				function Cmp(){}
+				Cmp.prototype.view = function(){return m("div")}
+				mount(root, Cmp)
 
-		// Wrapped to ensure no redraw fired
-		setTimeout(function() {
-			o(onupdate.callCount).equals(0)
+				o(root.firstChild.nodeName).equals("DIV")
+			})
 
-			done()
-		}, FRAME_BUDGET)
-	})
-
-	o("redraws when the render function is run", function(done) {
-		var onupdate = o.spy()
-		var oninit = o.spy()
-
-		mount(root, {
-			view : function() {
-				return m("div", {
-					oninit: oninit,
-					onupdate: onupdate
+			o("renders into `root` (closure component)", function() {
+				mount(root, function(){
+					return {
+						view : function() {
+							return m("div")
+						}
+					}
 				})
-			}
+
+				o(root.firstChild.nodeName).equals("DIV")
+			})
+
+			o("mounting null unmounts", function() {
+				mount(root, {
+					view : function() {
+						return m("div")
+					}
+				})
+
+				mount(root, null)
+
+				o(root.childNodes.length).equals(0)
+			})
+
+			o("redraws on events", function(done) {
+				var onupdate = o.spy()
+				var oninit   = o.spy()
+				var onclick  = o.spy()
+				var e = $window.document.createEvent("MouseEvents")
+
+				e.initEvent("click", true, true)
+
+				mount(root, {
+					view : function() {
+						return m("div", {
+							oninit   : oninit,
+							onupdate : onupdate,
+							onclick  : onclick,
+						})
+					}
+				})
+
+				root.firstChild.dispatchEvent(e)
+
+				o(oninit.callCount).equals(1)
+				o(onupdate.callCount).equals(0)
+
+				o(onclick.callCount).equals(1)
+				o(onclick.this).equals(root.firstChild)
+				o(onclick.args[0].type).equals("click")
+				o(onclick.args[0].target).equals(root.firstChild)
+
+				// Wrapped to give time for the rate-limited redraw to fire
+				setTimeout(function() {
+					o(onupdate.callCount).equals(1)
+
+					done()
+				}, FRAME_BUDGET)
+			})
+
+			o("redraws several mount points on events", function(done, timeout) {
+				timeout(60)
+				
+				var onupdate0 = o.spy()
+				var oninit0   = o.spy()
+				var onclick0  = o.spy()
+				var onupdate1 = o.spy()
+				var oninit1   = o.spy()
+				var onclick1  = o.spy()
+
+				var e = $window.document.createEvent("MouseEvents")
+
+				e.initEvent("click", true, true)
+
+				render(root, [
+					m("#child0"),
+					m("#child1")
+				])
+
+				mount(root.childNodes[0], {
+					view : function() {
+						return m("div", {
+							oninit   : oninit0,
+							onupdate : onupdate0,
+							onclick  : onclick0,
+						})
+					}
+				})
+
+				o(oninit0.callCount).equals(1)
+				o(onupdate0.callCount).equals(0)
+
+				mount(root.childNodes[1], {
+					view : function() {
+						return m("div", {
+							oninit   : oninit1,
+							onupdate : onupdate1,
+							onclick  : onclick1,
+						})
+					}
+				})
+
+				o(oninit1.callCount).equals(1)
+				o(onupdate1.callCount).equals(0)
+
+				root.childNodes[0].firstChild.dispatchEvent(e)
+				o(onclick0.callCount).equals(1)
+				o(onclick0.this).equals(root.childNodes[0].firstChild)
+
+				setTimeout(function() {
+					o(onupdate0.callCount).equals(1)
+					o(onupdate1.callCount).equals(1)
+
+					root.childNodes[1].firstChild.dispatchEvent(e)
+					o(onclick1.callCount).equals(1)
+					o(onclick1.this).equals(root.childNodes[1].firstChild)
+
+					setTimeout(function() {
+						o(onupdate0.callCount).equals(2)
+						o(onupdate1.callCount).equals(2)
+
+						done()
+					}, FRAME_BUDGET)
+				}, FRAME_BUDGET)
+
+			})
+
+			o("event handlers can skip redraw", function(done) {
+				var onupdate = o.spy()
+				var oninit = o.spy()
+				var e = $window.document.createEvent("MouseEvents")
+
+				e.initEvent("click", true, true)
+
+				mount(root, {
+					view: function() {
+						return m("div", {
+							oninit: oninit,
+							onupdate: onupdate,
+							onclick: function(e) {
+								e.redraw = false
+							}
+						})
+					}
+				})
+
+				root.firstChild.dispatchEvent(e)
+
+				o(oninit.callCount).equals(1)
+
+				// Wrapped to ensure no redraw fired
+				setTimeout(function() {
+					o(onupdate.callCount).equals(0)
+
+					done()
+				}, FRAME_BUDGET)
+			})
+
+			o("redraws when the render function is run", function(done) {
+				var onupdate = o.spy()
+				var oninit = o.spy()
+
+				mount(root, {
+					view : function() {
+						return m("div", {
+							oninit: oninit,
+							onupdate: onupdate
+						})
+					}
+				})
+
+				o(oninit.callCount).equals(1)
+				o(onupdate.callCount).equals(0)
+
+				redrawService.redraw()
+
+				// Wrapped to give time for the rate-limited redraw to fire
+				setTimeout(function() {
+					o(onupdate.callCount).equals(1)
+
+					done()
+				}, FRAME_BUDGET)
+			})
+			
+			o("throttles", function(done, timeout) {
+				timeout(200)
+
+				var i = 0
+				mount(root, {view: function() {i++}})
+				var before = i
+
+				redrawService.redraw()
+				redrawService.redraw()
+				redrawService.redraw()
+				redrawService.redraw()
+
+				var after = i
+
+				setTimeout(function(){
+					o(before).equals(1) // mounts synchronously
+					o(after).equals(1) // throttles rest
+					o(i).equals(2)
+					done()
+				},40)
+			})
 		})
-
-		o(oninit.callCount).equals(1)
-		o(onupdate.callCount).equals(0)
-
-		redrawService.redraw()
-
-		// Wrapped to give time for the rate-limited redraw to fire
-		setTimeout(function() {
-			o(onupdate.callCount).equals(1)
-
-			done()
-		}, FRAME_BUDGET)
 	})
-	
-	o("throttles", function(done, timeout) {
-		timeout(200)
-
-		var i = 0
-		mount(root, {view: function() {i++}})
-		var before = i
-
-		redrawService.redraw()
-		redrawService.redraw()
-		redrawService.redraw()
-		redrawService.redraw()
-
-		var after = i
-
-		setTimeout(function(){
-			o(before).equals(1) // mounts synchronously
-			o(after).equals(1) // throttles rest
-			o(i).equals(2)
-			done()
-		},40)
-	})
-})
+})
\ No newline at end of file
diff --git a/render/tests/test-component.js b/render/tests/test-component.js
index ed70fe7d..0f2ceaa3 100644
--- a/render/tests/test-component.js
+++ b/render/tests/test-component.js
@@ -1,6 +1,7 @@
 "use strict"
 
 var o = require("../../ospec/ospec")
+var components = require("../../test-utils/components")
 var domMock = require("../../test-utils/domMock")
 var vdom = require("../../render/render")
 
@@ -13,689 +14,695 @@ o.spec("component", function() {
 		render = vdom($window).render
 	})
 
-	o.spec("basics", function() {
-		o("works", function() {
-			var component = {
-				view: function() {
-					return {tag: "div", attrs: {id: "a"}, text: "b"}
-				}
-			}
-			var node = {tag: component}
+	;[components[0]].forEach(function(cmp){
+		o.spec(cmp.kind, function(){
+			var createComponent = cmp.create
 
-			render(root, [node])
+			o.spec("basics", function() {
+				o("works", function() {
+					var component = {
+						view: function() {
+							return {tag: "div", attrs: {id: "a"}, text: "b"}
+						}
+					}
+					var node = {tag: component}
 
-			o(root.firstChild.nodeName).equals("DIV")
-			o(root.firstChild.attributes["id"].nodeValue).equals("a")
-			o(root.firstChild.firstChild.nodeValue).equals("b")
-		})
-		o("receives arguments", function() {
-			var component = {
-				view: function(vnode) {
-					return {tag: "div", attrs: vnode.attrs, text: vnode.text}
-				}
-			}
-			var node = {tag: component, attrs: {id: "a"}, text: "b"}
+					render(root, [node])
 
-			render(root, [node])
+					o(root.firstChild.nodeName).equals("DIV")
+					o(root.firstChild.attributes["id"].nodeValue).equals("a")
+					o(root.firstChild.firstChild.nodeValue).equals("b")
+				})
+				o("receives arguments", function() {
+					var component = {
+						view: function(vnode) {
+							return {tag: "div", attrs: vnode.attrs, text: vnode.text}
+						}
+					}
+					var node = {tag: component, attrs: {id: "a"}, text: "b"}
 
-			o(root.firstChild.nodeName).equals("DIV")
-			o(root.firstChild.attributes["id"].nodeValue).equals("a")
-			o(root.firstChild.firstChild.nodeValue).equals("b")
-		})
-		o("updates", function() {
-			var component = {
-				view: function(vnode) {
-					return {tag: "div", attrs: vnode.attrs, text: vnode.text}
-				}
-			}
-			render(root, [{tag: component, attrs: {id: "a"}, text: "b"}])
-			render(root, [{tag: component, attrs: {id: "c"}, text: "d"}])
+					render(root, [node])
 
-			o(root.firstChild.nodeName).equals("DIV")
-			o(root.firstChild.attributes["id"].nodeValue).equals("c")
-			o(root.firstChild.firstChild.nodeValue).equals("d")
-		})
-		o("updates root from null", function() {
-			var visible = false
-			var component = {
-				view: function(vnode) {
-					return visible ? {tag: "div"} : null
-				}
-			}
-			render(root, [{tag: component}])
-			visible = true
-			render(root, [{tag: component}])
+					o(root.firstChild.nodeName).equals("DIV")
+					o(root.firstChild.attributes["id"].nodeValue).equals("a")
+					o(root.firstChild.firstChild.nodeValue).equals("b")
+				})
+				o("updates", function() {
+					var component = {
+						view: function(vnode) {
+							return {tag: "div", attrs: vnode.attrs, text: vnode.text}
+						}
+					}
+					render(root, [{tag: component, attrs: {id: "a"}, text: "b"}])
+					render(root, [{tag: component, attrs: {id: "c"}, text: "d"}])
 
-			o(root.firstChild.nodeName).equals("DIV")
-		})
-		o("updates root from primitive", function() {
-			var visible = false
-			var component = {
-				view: function(vnode) {
-					return visible ? {tag: "div"} : false
-				}
-			}
-			render(root, [{tag: component}])
-			visible = true
-			render(root, [{tag: component}])
+					o(root.firstChild.nodeName).equals("DIV")
+					o(root.firstChild.attributes["id"].nodeValue).equals("c")
+					o(root.firstChild.firstChild.nodeValue).equals("d")
+				})
+				o("updates root from null", function() {
+					var visible = false
+					var component = {
+						view: function(vnode) {
+							return visible ? {tag: "div"} : null
+						}
+					}
+					render(root, [{tag: component}])
+					visible = true
+					render(root, [{tag: component}])
 
-			o(root.firstChild.nodeName).equals("DIV")
-		})
-		o("updates root to null", function() {
-			var visible = true
-			var component = {
-				view: function(vnode) {
-					return visible ? {tag: "div"} : null
-				}
-			}
-			render(root, [{tag: component}])
-			visible = false
-			render(root, [{tag: component}])
+					o(root.firstChild.nodeName).equals("DIV")
+				})
+				o("updates root from primitive", function() {
+					var visible = false
+					var component = {
+						view: function(vnode) {
+							return visible ? {tag: "div"} : false
+						}
+					}
+					render(root, [{tag: component}])
+					visible = true
+					render(root, [{tag: component}])
 
-			o(root.childNodes.length).equals(0)
-		})
-		o("updates root to primitive", function() {
-			var visible = true
-			var component = {
-				view: function(vnode) {
-					return visible ? {tag: "div"} : false
-				}
-			}
-			render(root, [{tag: component}])
-			visible = false
-			render(root, [{tag: component}])
+					o(root.firstChild.nodeName).equals("DIV")
+				})
+				o("updates root to null", function() {
+					var visible = true
+					var component = {
+						view: function(vnode) {
+							return visible ? {tag: "div"} : null
+						}
+					}
+					render(root, [{tag: component}])
+					visible = false
+					render(root, [{tag: component}])
 
-			o(root.firstChild.nodeValue).equals("")
-		})
-		o("updates root from null to null", function() {
-			var component = {
-				view: function(vnode) {
-					return null
-				}
-			}
-			render(root, [{tag: component}])
-			render(root, [{tag: component}])
-
-			o(root.childNodes.length).equals(0)
-		})
-		o("removes", function() {
-			var component = {
-				view: function(vnode) {
-					return {tag: "div"}
-				}
-			}
-			var div = {tag: "div", key: 2}
-			render(root, [{tag: component, key: 1}, div])
-			render(root, [{tag: "div", key: 2}])
-
-			o(root.childNodes.length).equals(1)
-			o(root.firstChild).equals(div.dom)
-		})
-		o("svg works when creating across component boundary", function() {
-			var component = {
-				view: function(vnode) {
-					return {tag: "g"}
-				}
-			}
-			render(root, [{tag: "svg", children: [{tag: component}]}])
-
-			o(root.firstChild.firstChild.namespaceURI).equals("http://www.w3.org/2000/svg")
-		})
-		o("svg works when updating across component boundary", function() {
-			var component = {
-				view: function(vnode) {
-					return {tag: "g"}
-				}
-			}
-			render(root, [{tag: "svg", children: [{tag: component}]}])
-			render(root, [{tag: "svg", children: [{tag: component}]}])
-
-			o(root.firstChild.firstChild.namespaceURI).equals("http://www.w3.org/2000/svg")
-		})
-	})
-	o.spec("return value", function() {
-		o("can return fragments", function() {
-			var component = {
-				view: function(vnode) {
-					return [
-						{tag: "label"},
-						{tag: "input"},
-					]
-				}
-			}
-			render(root, [{tag: component}])
-
-			o(root.childNodes.length).equals(2)
-			o(root.childNodes[0].nodeName).equals("LABEL")
-			o(root.childNodes[1].nodeName).equals("INPUT")
-		})
-		o("can return string", function() {
-			var component = {
-				view: function(vnode) {
-					return "a"
-				}
-			}
-			render(root, [{tag: component}])
-
-			o(root.firstChild.nodeType).equals(3)
-			o(root.firstChild.nodeValue).equals("a")
-		})
-		o("can return falsy string", function() {
-			var component = {
-				view: function(vnode) {
-					return ""
-				}
-			}
-			render(root, [{tag: component}])
-
-			o(root.firstChild.nodeType).equals(3)
-			o(root.firstChild.nodeValue).equals("")
-		})
-		o("can return number", function() {
-			var component = {
-				view: function(vnode) {
-					return 1
-				}
-			}
-			render(root, [{tag: component}])
-
-			o(root.firstChild.nodeType).equals(3)
-			o(root.firstChild.nodeValue).equals("1")
-		})
-		o("can return falsy number", function() {
-			var component = {
-				view: function(vnode) {
-					return 0
-				}
-			}
-			render(root, [{tag: component}])
-
-			o(root.firstChild.nodeType).equals(3)
-			o(root.firstChild.nodeValue).equals("0")
-		})
-		o("can return boolean", function() {
-			var component = {
-				view: function(vnode) {
-					return true
-				}
-			}
-			render(root, [{tag: component}])
-
-			o(root.firstChild.nodeType).equals(3)
-			o(root.firstChild.nodeValue).equals("true")
-		})
-		o("can return falsy boolean", function() {
-			var component = {
-				view: function(vnode) {
-					return false
-				}
-			}
-			render(root, [{tag: component}])
-
-			o(root.firstChild.nodeType).equals(3)
-			o(root.firstChild.nodeValue).equals("")
-		})
-		o("can return null", function() {
-			var component = {
-				view: function(vnode) {
-					return null
-				}
-			}
-			render(root, [{tag: component}])
-
-			o(root.childNodes.length).equals(0)
-		})
-		o("can return undefined", function() {
-			var component = {
-				view: function(vnode) {
-					return undefined
-				}
-			}
-			render(root, [{tag: component}])
-
-			o(root.childNodes.length).equals(0)
-		})
-		o("throws a custom error if it returns itself", function() {
-			// A view that returns its vnode would otherwise trigger an infinite loop
-			var component = {
-				view: function(vnode) {
-					return vnode
-				}
-			}
-			try {
-				render(root, [{tag: component}])
-			}
-			catch (e) {
-				o(e instanceof Error).equals(true)
-				// Call stack exception is a RangeError
-				o(e instanceof RangeError).equals(false)
-			}
-		})
-		o("can update when returning fragments", function() {
-			var component = {
-				view: function(vnode) {
-					return [
-						{tag: "label"},
-						{tag: "input"},
-					]
-				}
-			}
-			render(root, [{tag: component}])
-			render(root, [{tag: component}])
-
-			o(root.childNodes.length).equals(2)
-			o(root.childNodes[0].nodeName).equals("LABEL")
-			o(root.childNodes[1].nodeName).equals("INPUT")
-		})
-		o("can update when returning primitive", function() {
-			var component = {
-				view: function(vnode) {
-					return "a"
-				}
-			}
-			render(root, [{tag: component}])
-			render(root, [{tag: component}])
-
-			o(root.firstChild.nodeType).equals(3)
-			o(root.firstChild.nodeValue).equals("a")
-		})
-		o("can update when returning null", function() {
-			var component = {
-				view: function(vnode) {
-					return null
-				}
-			}
-			render(root, [{tag: component}])
-			render(root, [{tag: component}])
-
-			o(root.childNodes.length).equals(0)
-		})
-		o("can remove when returning fragments", function() {
-			var component = {
-				view: function(vnode) {
-					return [
-						{tag: "label"},
-						{tag: "input"},
-					]
-				}
-			}
-			var div = {tag: "div", key: 2}
-			render(root, [{tag: component, key: 1}, div])
-
-			render(root, [{tag: "div", key: 2}])
-
-			o(root.childNodes.length).equals(1)
-			o(root.firstChild).equals(div.dom)
-		})
-		o("can remove when returning primitive", function() {
-			var component = {
-				view: function(vnode) {
-					return "a"
-				}
-			}
-			var div = {tag: "div", key: 2}
-			render(root, [{tag: component, key: 1}, div])
-
-			render(root, [{tag: "div", key: 2}])
-
-			o(root.childNodes.length).equals(1)
-			o(root.firstChild).equals(div.dom)
-		})
-	})
-	o.spec("lifecycle", function() {
-		o("calls oninit", function() {
-			var called = 0
-			var component = {
-				oninit: function(vnode) {
-					called++
-
-					o(vnode.tag).equals(component)
-					o(vnode.dom).equals(undefined)
 					o(root.childNodes.length).equals(0)
-				},
-				view: function() {
-					return {tag: "div", attrs: {id: "a"}, text: "b"}
-				}
-			}
-			var node = {tag: component}
+				})
+				o("updates root to primitive", function() {
+					var visible = true
+					var component = {
+						view: function(vnode) {
+							return visible ? {tag: "div"} : false
+						}
+					}
+					render(root, [{tag: component}])
+					visible = false
+					render(root, [{tag: component}])
 
-			render(root, [node])
+					o(root.firstChild.nodeValue).equals("")
+				})
+				o("updates root from null to null", function() {
+					var component = {
+						view: function(vnode) {
+							return null
+						}
+					}
+					render(root, [{tag: component}])
+					render(root, [{tag: component}])
 
-			o(called).equals(1)
-			o(root.firstChild.nodeName).equals("DIV")
-			o(root.firstChild.attributes["id"].nodeValue).equals("a")
-			o(root.firstChild.firstChild.nodeValue).equals("b")
-		})
-		o("calls oninit when returning fragment", function() {
-			var called = 0
-			var component = {
-				oninit: function(vnode) {
-					called++
-
-					o(vnode.tag).equals(component)
-					o(vnode.dom).equals(undefined)
 					o(root.childNodes.length).equals(0)
-				},
-				view: function() {
-					return [{tag: "div", attrs: {id: "a"}, text: "b"}]
-				}
-			}
-			var node = {tag: component}
+				})
+				o("removes", function() {
+					var component = {
+						view: function(vnode) {
+							return {tag: "div"}
+						}
+					}
+					var div = {tag: "div", key: 2}
+					render(root, [{tag: component, key: 1}, div])
+					render(root, [{tag: "div", key: 2}])
 
-			render(root, [node])
+					o(root.childNodes.length).equals(1)
+					o(root.firstChild).equals(div.dom)
+				})
+				o("svg works when creating across component boundary", function() {
+					var component = {
+						view: function(vnode) {
+							return {tag: "g"}
+						}
+					}
+					render(root, [{tag: "svg", children: [{tag: component}]}])
 
-			o(called).equals(1)
-			o(root.firstChild.nodeName).equals("DIV")
-			o(root.firstChild.attributes["id"].nodeValue).equals("a")
-			o(root.firstChild.firstChild.nodeValue).equals("b")
-		})
-		o("calls oninit before view", function() {
-			var viewCalled = false
+					o(root.firstChild.firstChild.namespaceURI).equals("http://www.w3.org/2000/svg")
+				})
+				o("svg works when updating across component boundary", function() {
+					var component = {
+						view: function(vnode) {
+							return {tag: "g"}
+						}
+					}
+					render(root, [{tag: "svg", children: [{tag: component}]}])
+					render(root, [{tag: "svg", children: [{tag: component}]}])
 
-			render(root, {
-				tag: {
-					view: function() {
-						viewCalled = true
-						return [{tag: "div", attrs: {id: "a"}, text: "b"}]
-					},
-					oninit: function(vnode) {
-						o(viewCalled).equals(false)
-					},
-				}
+					o(root.firstChild.firstChild.namespaceURI).equals("http://www.w3.org/2000/svg")
+				})
+			})
+			o.spec("return value", function() {
+				o("can return fragments", function() {
+					var component = {
+						view: function(vnode) {
+							return [
+								{tag: "label"},
+								{tag: "input"},
+							]
+						}
+					}
+					render(root, [{tag: component}])
+
+					o(root.childNodes.length).equals(2)
+					o(root.childNodes[0].nodeName).equals("LABEL")
+					o(root.childNodes[1].nodeName).equals("INPUT")
+				})
+				o("can return string", function() {
+					var component = {
+						view: function(vnode) {
+							return "a"
+						}
+					}
+					render(root, [{tag: component}])
+
+					o(root.firstChild.nodeType).equals(3)
+					o(root.firstChild.nodeValue).equals("a")
+				})
+				o("can return falsy string", function() {
+					var component = {
+						view: function(vnode) {
+							return ""
+						}
+					}
+					render(root, [{tag: component}])
+
+					o(root.firstChild.nodeType).equals(3)
+					o(root.firstChild.nodeValue).equals("")
+				})
+				o("can return number", function() {
+					var component = {
+						view: function(vnode) {
+							return 1
+						}
+					}
+					render(root, [{tag: component}])
+
+					o(root.firstChild.nodeType).equals(3)
+					o(root.firstChild.nodeValue).equals("1")
+				})
+				o("can return falsy number", function() {
+					var component = {
+						view: function(vnode) {
+							return 0
+						}
+					}
+					render(root, [{tag: component}])
+
+					o(root.firstChild.nodeType).equals(3)
+					o(root.firstChild.nodeValue).equals("0")
+				})
+				o("can return boolean", function() {
+					var component = {
+						view: function(vnode) {
+							return true
+						}
+					}
+					render(root, [{tag: component}])
+
+					o(root.firstChild.nodeType).equals(3)
+					o(root.firstChild.nodeValue).equals("true")
+				})
+				o("can return falsy boolean", function() {
+					var component = {
+						view: function(vnode) {
+							return false
+						}
+					}
+					render(root, [{tag: component}])
+
+					o(root.firstChild.nodeType).equals(3)
+					o(root.firstChild.nodeValue).equals("")
+				})
+				o("can return null", function() {
+					var component = {
+						view: function(vnode) {
+							return null
+						}
+					}
+					render(root, [{tag: component}])
+
+					o(root.childNodes.length).equals(0)
+				})
+				o("can return undefined", function() {
+					var component = {
+						view: function(vnode) {
+							return undefined
+						}
+					}
+					render(root, [{tag: component}])
+
+					o(root.childNodes.length).equals(0)
+				})
+				o("throws a custom error if it returns itself", function() {
+					// A view that returns its vnode would otherwise trigger an infinite loop
+					var component = {
+						view: function(vnode) {
+							return vnode
+						}
+					}
+					try {
+						render(root, [{tag: component}])
+					}
+					catch (e) {
+						o(e instanceof Error).equals(true)
+						// Call stack exception is a RangeError
+						o(e instanceof RangeError).equals(false)
+					}
+				})
+				o("can update when returning fragments", function() {
+					var component = {
+						view: function(vnode) {
+							return [
+								{tag: "label"},
+								{tag: "input"},
+							]
+						}
+					}
+					render(root, [{tag: component}])
+					render(root, [{tag: component}])
+
+					o(root.childNodes.length).equals(2)
+					o(root.childNodes[0].nodeName).equals("LABEL")
+					o(root.childNodes[1].nodeName).equals("INPUT")
+				})
+				o("can update when returning primitive", function() {
+					var component = {
+						view: function(vnode) {
+							return "a"
+						}
+					}
+					render(root, [{tag: component}])
+					render(root, [{tag: component}])
+
+					o(root.firstChild.nodeType).equals(3)
+					o(root.firstChild.nodeValue).equals("a")
+				})
+				o("can update when returning null", function() {
+					var component = {
+						view: function(vnode) {
+							return null
+						}
+					}
+					render(root, [{tag: component}])
+					render(root, [{tag: component}])
+
+					o(root.childNodes.length).equals(0)
+				})
+				o("can remove when returning fragments", function() {
+					var component = {
+						view: function(vnode) {
+							return [
+								{tag: "label"},
+								{tag: "input"},
+							]
+						}
+					}
+					var div = {tag: "div", key: 2}
+					render(root, [{tag: component, key: 1}, div])
+
+					render(root, [{tag: "div", key: 2}])
+
+					o(root.childNodes.length).equals(1)
+					o(root.firstChild).equals(div.dom)
+				})
+				o("can remove when returning primitive", function() {
+					var component = {
+						view: function(vnode) {
+							return "a"
+						}
+					}
+					var div = {tag: "div", key: 2}
+					render(root, [{tag: component, key: 1}, div])
+
+					render(root, [{tag: "div", key: 2}])
+
+					o(root.childNodes.length).equals(1)
+					o(root.firstChild).equals(div.dom)
+				})
+			})
+			o.spec("lifecycle", function() {
+				o("calls oninit", function() {
+					var called = 0
+					var component = {
+						oninit: function(vnode) {
+							called++
+
+							o(vnode.tag).equals(component)
+							o(vnode.dom).equals(undefined)
+							o(root.childNodes.length).equals(0)
+						},
+						view: function() {
+							return {tag: "div", attrs: {id: "a"}, text: "b"}
+						}
+					}
+					var node = {tag: component}
+
+					render(root, [node])
+
+					o(called).equals(1)
+					o(root.firstChild.nodeName).equals("DIV")
+					o(root.firstChild.attributes["id"].nodeValue).equals("a")
+					o(root.firstChild.firstChild.nodeValue).equals("b")
+				})
+				o("calls oninit when returning fragment", function() {
+					var called = 0
+					var component = {
+						oninit: function(vnode) {
+							called++
+
+							o(vnode.tag).equals(component)
+							o(vnode.dom).equals(undefined)
+							o(root.childNodes.length).equals(0)
+						},
+						view: function() {
+							return [{tag: "div", attrs: {id: "a"}, text: "b"}]
+						}
+					}
+					var node = {tag: component}
+
+					render(root, [node])
+
+					o(called).equals(1)
+					o(root.firstChild.nodeName).equals("DIV")
+					o(root.firstChild.attributes["id"].nodeValue).equals("a")
+					o(root.firstChild.firstChild.nodeValue).equals("b")
+				})
+				o("calls oninit before view", function() {
+					var viewCalled = false
+
+					render(root, {
+						tag: {
+							view: function() {
+								viewCalled = true
+								return [{tag: "div", attrs: {id: "a"}, text: "b"}]
+							},
+							oninit: function(vnode) {
+								o(viewCalled).equals(false)
+							},
+						}
+					})
+				})
+				o("does not calls oninit on redraw", function() {
+					var init = o.spy()
+					var component = {
+						view: function() {
+							return {tag: "div", attrs: {id: "a"}, text: "b"}
+						},
+						oninit: init,
+					}
+
+					function view() {
+						return {tag: component}
+					}
+
+					render(root, view())
+					render(root, view())
+
+					o(init.callCount).equals(1)
+				})
+				o("calls oncreate", function() {
+					var called = 0
+					var component = {
+						oncreate: function(vnode) {
+							called++
+
+							o(vnode.dom).notEquals(undefined)
+							o(vnode.dom).equals(root.firstChild)
+							o(root.childNodes.length).equals(1)
+						},
+						view: function() {
+							return {tag: "div", attrs: {id: "a"}, text: "b"}
+						}
+					}
+					var node = {tag: component}
+
+					render(root, [node])
+
+					o(called).equals(1)
+					o(root.firstChild.nodeName).equals("DIV")
+					o(root.firstChild.attributes["id"].nodeValue).equals("a")
+					o(root.firstChild.firstChild.nodeValue).equals("b")
+				})
+				o("does not calls oncreate on redraw", function() {
+					var create = o.spy()
+					var component = {
+						view: function() {
+							return {tag: "div", attrs: {id: "a"}, text: "b"}
+						},
+						oncreate: create,
+					}
+
+					function view() {
+						return {tag: component}
+					}
+
+					render(root, view())
+					render(root, view())
+
+					o(create.callCount).equals(1)
+				})
+				o("calls oncreate when returning fragment", function() {
+					var called = 0
+					var component = {
+						oncreate: function(vnode) {
+							called++
+
+							o(vnode.dom).notEquals(undefined)
+							o(vnode.dom).equals(root.firstChild)
+							o(root.childNodes.length).equals(1)
+						},
+						view: function() {
+							return [{tag: "div", attrs: {id: "a"}, text: "b"}]
+						}
+					}
+					var node = {tag: component}
+
+					render(root, [node])
+
+					o(called).equals(1)
+					o(root.firstChild.nodeName).equals("DIV")
+					o(root.firstChild.attributes["id"].nodeValue).equals("a")
+					o(root.firstChild.firstChild.nodeValue).equals("b")
+				})
+				o("calls onupdate", function() {
+					var called = 0
+					var component = {
+						onupdate: function(vnode) {
+							called++
+
+							o(vnode.dom).notEquals(undefined)
+							o(vnode.dom).equals(root.firstChild)
+							o(root.childNodes.length).equals(1)
+						},
+						view: function() {
+							return {tag: "div", attrs: {id: "a"}, text: "b"}
+						}
+					}
+
+					render(root, [{tag: component}])
+
+					o(called).equals(0)
+
+					render(root, [{tag: component}])
+
+					o(called).equals(1)
+					o(root.firstChild.nodeName).equals("DIV")
+					o(root.firstChild.attributes["id"].nodeValue).equals("a")
+					o(root.firstChild.firstChild.nodeValue).equals("b")
+				})
+				o("calls onupdate when returning fragment", function() {
+					var called = 0
+					var component = {
+						onupdate: function(vnode) {
+							called++
+
+							o(vnode.dom).notEquals(undefined)
+							o(vnode.dom).equals(root.firstChild)
+							o(root.childNodes.length).equals(1)
+						},
+						view: function() {
+							return [{tag: "div", attrs: {id: "a"}, text: "b"}]
+						}
+					}
+
+					render(root, [{tag: component}])
+
+					o(called).equals(0)
+
+					render(root, [{tag: component}])
+
+					o(called).equals(1)
+					o(root.firstChild.nodeName).equals("DIV")
+					o(root.firstChild.attributes["id"].nodeValue).equals("a")
+					o(root.firstChild.firstChild.nodeValue).equals("b")
+				})
+				o("calls onremove", function() {
+					var called = 0
+					var component = {
+						onremove: function(vnode) {
+							called++
+
+							o(vnode.dom).notEquals(undefined)
+							o(vnode.dom).equals(root.firstChild)
+							o(root.childNodes.length).equals(1)
+						},
+						view: function() {
+							return {tag: "div", attrs: {id: "a"}, text: "b"}
+						}
+					}
+
+					render(root, [{tag: component}])
+
+					o(called).equals(0)
+
+					render(root, [])
+
+					o(called).equals(1)
+					o(root.childNodes.length).equals(0)
+				})
+				o("calls onremove when returning fragment", function() {
+					var called = 0
+					var component = {
+						onremove: function(vnode) {
+							called++
+
+							o(vnode.dom).notEquals(undefined)
+							o(vnode.dom).equals(root.firstChild)
+							o(root.childNodes.length).equals(1)
+						},
+						view: function() {
+							return [{tag: "div", attrs: {id: "a"}, text: "b"}]
+						}
+					}
+
+					render(root, [{tag: component}])
+
+					o(called).equals(0)
+
+					render(root, [])
+
+					o(called).equals(1)
+					o(root.childNodes.length).equals(0)
+				})
+				o("calls onbeforeremove", function() {
+					var called = 0
+					var component = {
+						onbeforeremove: function(vnode) {
+							called++
+
+							o(vnode.dom).notEquals(undefined)
+							o(vnode.dom).equals(root.firstChild)
+							o(root.childNodes.length).equals(1)
+						},
+						view: function() {
+							return {tag: "div", attrs: {id: "a"}, text: "b"}
+						}
+					}
+
+					render(root, [{tag: component}])
+
+					o(called).equals(0)
+
+					render(root, [])
+
+					o(called).equals(1)
+					o(root.childNodes.length).equals(0)
+				})
+				o("calls onbeforeremove when returning fragment", function() {
+					var called = 0
+					var component = {
+						onbeforeremove: function(vnode) {
+							called++
+
+							o(vnode.dom).notEquals(undefined)
+							o(vnode.dom).equals(root.firstChild)
+							o(root.childNodes.length).equals(1)
+						},
+						view: function() {
+							return [{tag: "div", attrs: {id: "a"}, text: "b"}]
+						}
+					}
+
+					render(root, [{tag: component}])
+
+					o(called).equals(0)
+
+					render(root, [])
+
+					o(called).equals(1)
+					o(root.childNodes.length).equals(0)
+				})
+				o("does not recycle when there's an onupdate", function() {
+					var component = {
+						onupdate: function() {},
+						view: function() {
+							return {tag: "div"}
+						}
+					}
+					var update = o.spy()
+					var vnode = {tag: component, key: 1}
+					var updated = {tag: component, key: 1}
+
+					render(root, [vnode])
+					render(root, [])
+					render(root, [updated])
+
+					o(vnode.dom).notEquals(updated.dom)
+				})
+			})
+			o.spec("state", function() {
+				o("copies state", function() {
+					var called = 0
+					var data = {a: 1}
+					var component = {
+						data: data,
+						oninit: init,
+						view: function() {
+							return ""
+						}
+					}
+
+					render(root, [{tag: component}])
+
+					function init(vnode) {
+						o(vnode.state.data).deepEquals(data)
+						o(vnode.state.data).equals(data)
+
+						//inherits state via prototype
+						component.x = 1
+						o(vnode.state.x).equals(1)
+					}
+				})
+				o("state copy is shallow", function() {
+					var called = 0
+					var body = {a: 1}
+					var data = [body]
+					var component = {
+						data: data,
+						oninit: init,
+						view: function() {
+							return ""
+						}
+					}
+
+					render(root, [{tag: component}])
+
+					function init(vnode) {
+						o(vnode.state.data).equals(data)
+						o(vnode.state.data[0]).equals(body)
+					}
+				})
 			})
 		})
-		o("does not calls oninit on redraw", function() {
-			var init = o.spy()
-			var component = {
-				view: function() {
-					return {tag: "div", attrs: {id: "a"}, text: "b"}
-				},
-				oninit: init,
-			}
-
-			function view() {
-				return {tag: component}
-			}
-
-			render(root, view())
-			render(root, view())
-
-			o(init.callCount).equals(1)
-		})
-		o("calls oncreate", function() {
-			var called = 0
-			var component = {
-				oncreate: function(vnode) {
-					called++
-
-					o(vnode.dom).notEquals(undefined)
-					o(vnode.dom).equals(root.firstChild)
-					o(root.childNodes.length).equals(1)
-				},
-				view: function() {
-					return {tag: "div", attrs: {id: "a"}, text: "b"}
-				}
-			}
-			var node = {tag: component}
-
-			render(root, [node])
-
-			o(called).equals(1)
-			o(root.firstChild.nodeName).equals("DIV")
-			o(root.firstChild.attributes["id"].nodeValue).equals("a")
-			o(root.firstChild.firstChild.nodeValue).equals("b")
-		})
-		o("does not calls oncreate on redraw", function() {
-			var create = o.spy()
-			var component = {
-				view: function() {
-					return {tag: "div", attrs: {id: "a"}, text: "b"}
-				},
-				oncreate: create,
-			}
-
-			function view() {
-				return {tag: component}
-			}
-
-			render(root, view())
-			render(root, view())
-
-			o(create.callCount).equals(1)
-		})
-		o("calls oncreate when returning fragment", function() {
-			var called = 0
-			var component = {
-				oncreate: function(vnode) {
-					called++
-
-					o(vnode.dom).notEquals(undefined)
-					o(vnode.dom).equals(root.firstChild)
-					o(root.childNodes.length).equals(1)
-				},
-				view: function() {
-					return [{tag: "div", attrs: {id: "a"}, text: "b"}]
-				}
-			}
-			var node = {tag: component}
-
-			render(root, [node])
-
-			o(called).equals(1)
-			o(root.firstChild.nodeName).equals("DIV")
-			o(root.firstChild.attributes["id"].nodeValue).equals("a")
-			o(root.firstChild.firstChild.nodeValue).equals("b")
-		})
-		o("calls onupdate", function() {
-			var called = 0
-			var component = {
-				onupdate: function(vnode) {
-					called++
-
-					o(vnode.dom).notEquals(undefined)
-					o(vnode.dom).equals(root.firstChild)
-					o(root.childNodes.length).equals(1)
-				},
-				view: function() {
-					return {tag: "div", attrs: {id: "a"}, text: "b"}
-				}
-			}
-
-			render(root, [{tag: component}])
-
-			o(called).equals(0)
-
-			render(root, [{tag: component}])
-
-			o(called).equals(1)
-			o(root.firstChild.nodeName).equals("DIV")
-			o(root.firstChild.attributes["id"].nodeValue).equals("a")
-			o(root.firstChild.firstChild.nodeValue).equals("b")
-		})
-		o("calls onupdate when returning fragment", function() {
-			var called = 0
-			var component = {
-				onupdate: function(vnode) {
-					called++
-
-					o(vnode.dom).notEquals(undefined)
-					o(vnode.dom).equals(root.firstChild)
-					o(root.childNodes.length).equals(1)
-				},
-				view: function() {
-					return [{tag: "div", attrs: {id: "a"}, text: "b"}]
-				}
-			}
-
-			render(root, [{tag: component}])
-
-			o(called).equals(0)
-
-			render(root, [{tag: component}])
-
-			o(called).equals(1)
-			o(root.firstChild.nodeName).equals("DIV")
-			o(root.firstChild.attributes["id"].nodeValue).equals("a")
-			o(root.firstChild.firstChild.nodeValue).equals("b")
-		})
-		o("calls onremove", function() {
-			var called = 0
-			var component = {
-				onremove: function(vnode) {
-					called++
-
-					o(vnode.dom).notEquals(undefined)
-					o(vnode.dom).equals(root.firstChild)
-					o(root.childNodes.length).equals(1)
-				},
-				view: function() {
-					return {tag: "div", attrs: {id: "a"}, text: "b"}
-				}
-			}
-
-			render(root, [{tag: component}])
-
-			o(called).equals(0)
-
-			render(root, [])
-
-			o(called).equals(1)
-			o(root.childNodes.length).equals(0)
-		})
-		o("calls onremove when returning fragment", function() {
-			var called = 0
-			var component = {
-				onremove: function(vnode) {
-					called++
-
-					o(vnode.dom).notEquals(undefined)
-					o(vnode.dom).equals(root.firstChild)
-					o(root.childNodes.length).equals(1)
-				},
-				view: function() {
-					return [{tag: "div", attrs: {id: "a"}, text: "b"}]
-				}
-			}
-
-			render(root, [{tag: component}])
-
-			o(called).equals(0)
-
-			render(root, [])
-
-			o(called).equals(1)
-			o(root.childNodes.length).equals(0)
-		})
-		o("calls onbeforeremove", function() {
-			var called = 0
-			var component = {
-				onbeforeremove: function(vnode) {
-					called++
-
-					o(vnode.dom).notEquals(undefined)
-					o(vnode.dom).equals(root.firstChild)
-					o(root.childNodes.length).equals(1)
-				},
-				view: function() {
-					return {tag: "div", attrs: {id: "a"}, text: "b"}
-				}
-			}
-
-			render(root, [{tag: component}])
-
-			o(called).equals(0)
-
-			render(root, [])
-
-			o(called).equals(1)
-			o(root.childNodes.length).equals(0)
-		})
-		o("calls onbeforeremove when returning fragment", function() {
-			var called = 0
-			var component = {
-				onbeforeremove: function(vnode) {
-					called++
-
-					o(vnode.dom).notEquals(undefined)
-					o(vnode.dom).equals(root.firstChild)
-					o(root.childNodes.length).equals(1)
-				},
-				view: function() {
-					return [{tag: "div", attrs: {id: "a"}, text: "b"}]
-				}
-			}
-
-			render(root, [{tag: component}])
-
-			o(called).equals(0)
-
-			render(root, [])
-
-			o(called).equals(1)
-			o(root.childNodes.length).equals(0)
-		})
-		o("does not recycle when there's an onupdate", function() {
-			var component = {
-				onupdate: function() {},
-				view: function() {
-					return {tag: "div"}
-				}
-			}
-			var update = o.spy()
-			var vnode = {tag: component, key: 1}
-			var updated = {tag: component, key: 1}
-
-			render(root, [vnode])
-			render(root, [])
-			render(root, [updated])
-
-			o(vnode.dom).notEquals(updated.dom)
-		})
 	})
-	o.spec("state", function() {
-		o("copies state", function() {
-			var called = 0
-			var data = {a: 1}
-			var component = {
-				data: data,
-				oninit: init,
-				view: function() {
-					return ""
-				}
-			}
-
-			render(root, [{tag: component}])
-
-			function init(vnode) {
-				o(vnode.state.data).deepEquals(data)
-				o(vnode.state.data).equals(data)
-
-				//inherits state via prototype
-				component.x = 1
-				o(vnode.state.x).equals(1)
-			}
-		})
-		o("state copy is shallow", function() {
-			var called = 0
-			var body = {a: 1}
-			var data = [body]
-			var component = {
-				data: data,
-				oninit: init,
-				view: function() {
-					return ""
-				}
-			}
-
-			render(root, [{tag: component}])
-
-			function init(vnode) {
-				o(vnode.state.data).equals(data)
-				o(vnode.state.data[0]).equals(body)
-			}
-		})
-	})
-	o.spec("Alternative ways to specify componenents", function() {
+	o.spec("Alternative ways to specify components", function() {
 		o("Classes can be used as components", function() {
 			function MyComponent(vnode){
 				o(vnode.state).equals(null)
diff --git a/render/tests/test-onbeforeremove.js b/render/tests/test-onbeforeremove.js
index c9af4894..0a3ca8fe 100644
--- a/render/tests/test-onbeforeremove.js
+++ b/render/tests/test-onbeforeremove.js
@@ -2,6 +2,7 @@
 
 var o = require("../../ospec/ospec")
 var callAsync = require("../../test-utils/callAsync")
+var components = require("../../test-utils/components")
 var domMock = require("../../test-utils/domMock")
 var vdom = require("../../render/render")
 var Promise = require("../../promise/promise")
@@ -169,39 +170,44 @@ o.spec("onbeforeremove", function() {
 			done()
 		})
 	})
-	o("finalizes the remove phase asynchronously when promise is returned synchronously from both attrs- and tag.onbeforeremove", function(done) {
-		var onremove = o.spy()
-		var onbeforeremove = function(){return Promise.resolve()}
-		var component = {
-			onbeforeremove: onbeforeremove,
-			onremove: onremove,
-			view: function() {},
-		}
-		render(root, [{tag: component, attrs: {onbeforeremove: onbeforeremove, onremove: onremove}}])
-		render(root, [])
-		callAsync(function() {
-			o(onremove.callCount).equals(2) // once for `tag`, once for `attrs`
-			done()
-		})
-	})
-	o("awaits promise resolution before removing the node", function(done) {
-		var view = o.spy()
-		var onremove = o.spy()
-		var onbeforeremove = function(){return new Promise(function(resolve){callAsync(resolve)})}
-		var component = {
-			onbeforeremove: onbeforeremove,
-			onremove: onremove,
-			view: view,
-		}
-		render(root, [{tag: component}])
-		render(root, [])
+	;[components[0]].forEach(function(cmp){
+		o.spec(cmp.kind, function(){
+			var createComponent = cmp.create
+			o("finalizes the remove phase asynchronously when promise is returned synchronously from both attrs- and tag.onbeforeremove", function(done) {
+				var onremove = o.spy()
+				var onbeforeremove = function(){return Promise.resolve()}
+				var component = {
+					onbeforeremove: onbeforeremove,
+					onremove: onremove,
+					view: function() {},
+				}
+				render(root, [{tag: component, attrs: {onbeforeremove: onbeforeremove, onremove: onremove}}])
+				render(root, [])
+				callAsync(function() {
+					o(onremove.callCount).equals(2) // once for `tag`, once for `attrs`
+					done()
+				})
+			})
+			o("awaits promise resolution before removing the node", function(done) {
+				var view = o.spy()
+				var onremove = o.spy()
+				var onbeforeremove = function(){return new Promise(function(resolve){callAsync(resolve)})}
+				var component = {
+					onbeforeremove: onbeforeremove,
+					onremove: onremove,
+					view: view,
+				}
+				render(root, [{tag: component}])
+				render(root, [])
 
-		callAsync(function(){
-			o(onremove.callCount).equals(0)
+				callAsync(function(){
+					o(onremove.callCount).equals(0)
 
-			callAsync(function() {
-				o(onremove.callCount).equals(1)
-				done()
+					callAsync(function() {
+						o(onremove.callCount).equals(1)
+						done()
+					})
+				})
 			})
 		})
 	})
diff --git a/render/tests/test-onbeforeupdate.js b/render/tests/test-onbeforeupdate.js
index 2844e8ee..d637ab66 100644
--- a/render/tests/test-onbeforeupdate.js
+++ b/render/tests/test-onbeforeupdate.js
@@ -120,171 +120,177 @@ o.spec("onbeforeupdate", function() {
 		o(count).equals(1)
 	})
 
-	o("prevents update in component", function() {
-		var component = {
-			onbeforeupdate: function() {return false},
-			view: function(vnode) {
-				return {tag: "div", children: vnode.children}
-			},
-		}
-		var vnode = {tag: component, children: [{tag: "#", children: "a"}]}
-		var updated = {tag: component, children: [{tag: "#", children: "b"}]}
+	;[components[0]].forEach(function(cmp){
+		o.spec(cmp.kind, function(){
+			var createComponent = cmp.create
 
-		render(root, [vnode])
-		render(root, [updated])
+			o("prevents update in component", function() {
+				var component = {
+					onbeforeupdate: function() {return false},
+					view: function(vnode) {
+						return {tag: "div", children: vnode.children}
+					},
+				}
+				var vnode = {tag: component, children: [{tag: "#", children: "a"}]}
+				var updated = {tag: component, children: [{tag: "#", children: "b"}]}
 
-		o(root.firstChild.firstChild.nodeValue).equals("a")
+				render(root, [vnode])
+				render(root, [updated])
+
+				o(root.firstChild.firstChild.nodeValue).equals("a")
+			})
+
+			o("prevents update if returning false in component and false in vnode", function() {
+				var component = {
+					onbeforeupdate: function() {return false},
+					view: function(vnode) {
+						return {tag: "div", attrs: {id: vnode.attrs.id}}
+					},
+				}
+				var vnode = {tag: component, attrs: {id: "a", onbeforeupdate: function() {return false}}}
+				var updated = {tag: component, attrs: {id: "b", onbeforeupdate: function() {return false}}}
+
+				render(root, [vnode])
+				render(root, [updated])
+
+				o(root.firstChild.attributes["id"].nodeValue).equals("a")
+			})
+
+			o("does not prevent update if returning true in component and true in vnode", function() {
+				var component = {
+					onbeforeupdate: function() {return true},
+					view: function(vnode) {
+						return {tag: "div", attrs: {id: vnode.attrs.id}}
+					},
+				}
+				var vnode = {tag: component, attrs: {id: "a", onbeforeupdate: function() {return true}}}
+				var updated = {tag: component, attrs: {id: "b", onbeforeupdate: function() {return true}}}
+
+				render(root, [vnode])
+				render(root, [updated])
+
+				o(root.firstChild.attributes["id"].nodeValue).equals("b")
+			})
+
+			o("does not prevent update if returning false in component but true in vnode", function() {
+				var component = {
+					onbeforeupdate: function() {return false},
+					view: function(vnode) {
+						return {tag: "div", attrs: {id: vnode.attrs.id}}
+					},
+				}
+				var vnode = {tag: component, attrs: {id: "a", onbeforeupdate: function() {return true}}}
+				var updated = {tag: component, attrs: {id: "b", onbeforeupdate: function() {return true}}}
+
+				render(root, [vnode])
+				render(root, [updated])
+
+				o(root.firstChild.attributes["id"].nodeValue).equals("b")
+			})
+
+			o("does not prevent update if returning true in component but false in vnode", function() {
+				var component = {
+					onbeforeupdate: function() {return true},
+					view: function(vnode) {
+						return {tag: "div", attrs: {id: vnode.attrs.id}}
+					},
+				}
+				var vnode = {tag: component, attrs: {id: "a", onbeforeupdate: function() {return false}}}
+				var updated = {tag: component, attrs: {id: "b", onbeforeupdate: function() {return false}}}
+
+				render(root, [vnode])
+				render(root, [updated])
+
+				o(root.firstChild.attributes["id"].nodeValue).equals("b")
+			})
+
+			o("does not prevent update if returning true from component", function() {
+				var component = {
+					onbeforeupdate: function() {return true},
+					view: function(vnode) {
+						return {tag: "div", attrs: vnode.attrs}
+					},
+				}
+				var vnode = {tag: component, attrs: {id: "a"}}
+				var updated = {tag: component, attrs: {id: "b"}}
+
+				render(root, [vnode])
+				render(root, [updated])
+
+				o(root.firstChild.attributes["id"].nodeValue).equals("b")
+			})
+
+			o("accepts arguments for comparison in component", function() {
+				var component = {
+					onbeforeupdate: onbeforeupdate,
+					view: function(vnode) {
+						return {tag: "div", attrs: vnode.attrs}
+					},
+				}
+				var count = 0
+				var vnode = {tag: component, attrs: {id: "a"}}
+				var updated = {tag: component, attrs: {id: "b"}}
+
+				render(root, [vnode])
+				render(root, [updated])
+
+				function onbeforeupdate(vnode, old) {
+					count++
+
+					o(old.attrs.id).equals("a")
+					o(vnode.attrs.id).equals("b")
+
+					return old.attrs.id !== vnode.attrs.id
+				}
+
+				o(count).equals(1)
+				o(root.firstChild.attributes["id"].nodeValue).equals("b")
+			})
+
+			o("is not called on component creation", function() {
+				var component = {
+					onbeforeupdate: onbeforeupdate,
+					view: function(vnode) {
+						return {tag: "div", attrs: vnode.attrs}
+					},
+				}
+
+				var count = 0
+				var vnode = {tag: "div", attrs: {id: "a"}}
+				var updated = {tag: "div", attrs: {id: "b"}}
+
+				render(root, [vnode])
+
+				function onbeforeupdate(vnode, old) {
+					count++
+					return true
+				}
+
+				o(count).equals(0)
+			})
+
+			o("is called only once on component update", function() {
+				var component = {
+					onbeforeupdate: onbeforeupdate,
+					view: function(vnode) {
+						return {tag: "div", attrs: vnode.attrs}
+					},
+				}
+
+				var count = 0
+				var vnode = {tag: component, attrs: {id: "a"}}
+				var updated = {tag: component, attrs: {id: "b"}}
+
+				render(root, [vnode])
+				render(root, [updated])
+
+				function onbeforeupdate(vnode, old) {
+					count++
+					return true
+				}
+
+				o(count).equals(1)
+			})
+		})
 	})
-
-	o("prevents update if returning false in component and false in vnode", function() {
-		var component = {
-			onbeforeupdate: function() {return false},
-			view: function(vnode) {
-				return {tag: "div", attrs: {id: vnode.attrs.id}}
-			},
-		}
-		var vnode = {tag: component, attrs: {id: "a", onbeforeupdate: function() {return false}}}
-		var updated = {tag: component, attrs: {id: "b", onbeforeupdate: function() {return false}}}
-
-		render(root, [vnode])
-		render(root, [updated])
-
-		o(root.firstChild.attributes["id"].nodeValue).equals("a")
-	})
-
-	o("does not prevent update if returning true in component and true in vnode", function() {
-		var component = {
-			onbeforeupdate: function() {return true},
-			view: function(vnode) {
-				return {tag: "div", attrs: {id: vnode.attrs.id}}
-			},
-		}
-		var vnode = {tag: component, attrs: {id: "a", onbeforeupdate: function() {return true}}}
-		var updated = {tag: component, attrs: {id: "b", onbeforeupdate: function() {return true}}}
-
-		render(root, [vnode])
-		render(root, [updated])
-
-		o(root.firstChild.attributes["id"].nodeValue).equals("b")
-	})
-
-	o("does not prevent update if returning false in component but true in vnode", function() {
-		var component = {
-			onbeforeupdate: function() {return false},
-			view: function(vnode) {
-				return {tag: "div", attrs: {id: vnode.attrs.id}}
-			},
-		}
-		var vnode = {tag: component, attrs: {id: "a", onbeforeupdate: function() {return true}}}
-		var updated = {tag: component, attrs: {id: "b", onbeforeupdate: function() {return true}}}
-
-		render(root, [vnode])
-		render(root, [updated])
-
-		o(root.firstChild.attributes["id"].nodeValue).equals("b")
-	})
-
-	o("does not prevent update if returning true in component but false in vnode", function() {
-		var component = {
-			onbeforeupdate: function() {return true},
-			view: function(vnode) {
-				return {tag: "div", attrs: {id: vnode.attrs.id}}
-			},
-		}
-		var vnode = {tag: component, attrs: {id: "a", onbeforeupdate: function() {return false}}}
-		var updated = {tag: component, attrs: {id: "b", onbeforeupdate: function() {return false}}}
-
-		render(root, [vnode])
-		render(root, [updated])
-
-		o(root.firstChild.attributes["id"].nodeValue).equals("b")
-	})
-
-	o("does not prevent update if returning true from component", function() {
-		var component = {
-			onbeforeupdate: function() {return true},
-			view: function(vnode) {
-				return {tag: "div", attrs: vnode.attrs}
-			},
-		}
-		var vnode = {tag: component, attrs: {id: "a"}}
-		var updated = {tag: component, attrs: {id: "b"}}
-
-		render(root, [vnode])
-		render(root, [updated])
-
-		o(root.firstChild.attributes["id"].nodeValue).equals("b")
-	})
-
-	o("accepts arguments for comparison in component", function() {
-		var component = {
-			onbeforeupdate: onbeforeupdate,
-			view: function(vnode) {
-				return {tag: "div", attrs: vnode.attrs}
-			},
-		}
-		var count = 0
-		var vnode = {tag: component, attrs: {id: "a"}}
-		var updated = {tag: component, attrs: {id: "b"}}
-
-		render(root, [vnode])
-		render(root, [updated])
-
-		function onbeforeupdate(vnode, old) {
-			count++
-
-			o(old.attrs.id).equals("a")
-			o(vnode.attrs.id).equals("b")
-
-			return old.attrs.id !== vnode.attrs.id
-		}
-
-		o(count).equals(1)
-		o(root.firstChild.attributes["id"].nodeValue).equals("b")
-	})
-
-	o("is not called on component creation", function() {
-		var component = {
-			onbeforeupdate: onbeforeupdate,
-			view: function(vnode) {
-				return {tag: "div", attrs: vnode.attrs}
-			},
-		}
-
-		var count = 0
-		var vnode = {tag: "div", attrs: {id: "a"}}
-		var updated = {tag: "div", attrs: {id: "b"}}
-
-		render(root, [vnode])
-
-		function onbeforeupdate(vnode, old) {
-			count++
-			return true
-		}
-
-		o(count).equals(0)
-	})
-
-	o("is called only once on component update", function() {
-		var component = {
-			onbeforeupdate: onbeforeupdate,
-			view: function(vnode) {
-				return {tag: "div", attrs: vnode.attrs}
-			},
-		}
-
-		var count = 0
-		var vnode = {tag: component, attrs: {id: "a"}}
-		var updated = {tag: component, attrs: {id: "b"}}
-
-		render(root, [vnode])
-		render(root, [updated])
-
-		function onbeforeupdate(vnode, old) {
-			count++
-			return true
-		}
-
-		o(count).equals(1)
-	})
-})
+})
\ No newline at end of file
diff --git a/render/tests/test-onremove.js b/render/tests/test-onremove.js
index 8aa2eabd..e6e40f55 100644
--- a/render/tests/test-onremove.js
+++ b/render/tests/test-onremove.js
@@ -113,37 +113,43 @@ o.spec("onremove", function() {
 
 		o(vnode.dom).notEquals(updated.dom)
 	})
-	o("calls onremove on nested component", function() {
-		var spy = o.spy()
-		var comp = {
-			view: function() {return m(outer)}
-		}
-		var outer = {
-			view: function() {return m(inner)}
-		}
-		var inner = {
-			onremove: spy,
-			view: function() {return m("div")}
-		}
-		render(root, {tag: comp})
-		render(root, null)
-		
-		o(spy.callCount).equals(1)
+	;[components[0]].forEach(function(cmp){
+		o.spec(cmp.kind, function(){
+			var createComponent = cmp.create
+
+			o("calls onremove on nested component", function() {
+				var spy = o.spy()
+				var comp = {
+					view: function() {return m(outer)}
+				}
+				var outer = {
+					view: function() {return m(inner)}
+				}
+				var inner = {
+					onremove: spy,
+					view: function() {return m("div")}
+				}
+				render(root, {tag: comp})
+				render(root, null)
+				
+				o(spy.callCount).equals(1)
+			})
+			o("calls onremove on nested component child", function() {
+				var spy = o.spy()
+				var comp = {
+					view: function() {return m(outer)}
+				}
+				var outer = {
+					view: function() {return m(inner, m("a", {onremove: spy}))}
+				}
+				var inner = {
+					view: function(vnode) {return m("div", vnode.children)}
+				}
+				render(root, {tag: comp})
+				render(root, null)
+				
+				o(spy.callCount).equals(1)
+			})
+		})
 	})
-	o("calls onremove on nested component child", function() {
-		var spy = o.spy()
-		var comp = {
-			view: function() {return m(outer)}
-		}
-		var outer = {
-			view: function() {return m(inner, m("a", {onremove: spy}))}
-		}
-		var inner = {
-			view: function(vnode) {return m("div", vnode.children)}
-		}
-		render(root, {tag: comp})
-		render(root, null)
-		
-		o(spy.callCount).equals(1)
-	})
-})
+})
\ No newline at end of file
diff --git a/render/tests/test-updateNodes.js b/render/tests/test-updateNodes.js
index c7b7095c..2d11533a 100644
--- a/render/tests/test-updateNodes.js
+++ b/render/tests/test-updateNodes.js
@@ -905,36 +905,42 @@ o.spec("updateNodes", function() {
 		
 		o(vnode.dom).notEquals(updated.dom)
 	})
-	o("fragment child toggles from null when followed by null component then tag", function() {
-		var component = {view: function() {return null}}
-		var vnodes = [{tag: "[", children: [{tag: "a"}, {tag: component}, {tag: "b"}]}]
-		var temp = [{tag: "[", children: [null, {tag: component}, {tag: "b"}]}]
-		var updated = [{tag: "[", children: [{tag: "a"}, {tag: component}, {tag: "b"}]}]
+	;[components[0]].forEach(function(cmp){
+		o.spec(cmp.kind, function(){
+			var createComponent = cmp.create
 
-		render(root, vnodes)
-		render(root, temp)
-		render(root, updated)
+			o("fragment child toggles from null when followed by null component then tag", function() {
+				var component = {view: function() {return null}}
+				var vnodes = [{tag: "[", children: [{tag: "a"}, {tag: component}, {tag: "b"}]}]
+				var temp = [{tag: "[", children: [null, {tag: component}, {tag: "b"}]}]
+				var updated = [{tag: "[", children: [{tag: "a"}, {tag: component}, {tag: "b"}]}]
 
-		o(root.childNodes.length).equals(2)
-		o(root.childNodes[0].nodeName).equals("A")
-		o(root.childNodes[1].nodeName).equals("B")
+				render(root, vnodes)
+				render(root, temp)
+				render(root, updated)
+
+				o(root.childNodes.length).equals(2)
+				o(root.childNodes[0].nodeName).equals("A")
+				o(root.childNodes[1].nodeName).equals("B")
+			})
+			o("fragment child toggles from null in component when followed by null component then tag", function() {
+				var flag = true
+				var a = {view: function() {return flag ? {tag: "a"} : null}}
+				var b = {view: function() {return null}}
+				var vnodes = [{tag: "[", children: [{tag: a}, {tag: b}, {tag: "s"}]}]
+				var temp = [{tag: "[", children: [{tag: a}, {tag: b}, {tag: "s"}]}]
+				var updated = [{tag: "[", children: [{tag: a}, {tag: b}, {tag: "s"}]}]
+
+				render(root, vnodes)
+				flag = false
+				render(root, temp)
+				flag = true
+				render(root, updated)
+
+				o(root.childNodes.length).equals(2)
+				o(root.childNodes[0].nodeName).equals("A")
+				o(root.childNodes[1].nodeName).equals("S")
+			})
+		})
 	})
-	o("fragment child toggles from null in component when followed by null component then tag", function() {
-		var flag = true
-		var a = {view: function() {return flag ? {tag: "a"} : null}}
-		var b = {view: function() {return null}}
-		var vnodes = [{tag: "[", children: [{tag: a}, {tag: b}, {tag: "s"}]}]
-		var temp = [{tag: "[", children: [{tag: a}, {tag: b}, {tag: "s"}]}]
-		var updated = [{tag: "[", children: [{tag: a}, {tag: b}, {tag: "s"}]}]
-
-		render(root, vnodes)
-		flag = false
-		render(root, temp)
-		flag = true
-		render(root, updated)
-
-		o(root.childNodes.length).equals(2)
-		o(root.childNodes[0].nodeName).equals("A")
-		o(root.childNodes[1].nodeName).equals("S")
-	})
-})
+})
\ No newline at end of file
diff --git a/tests/test-api.js b/tests/test-api.js
index 59e3eb23..6a7d7ef4 100644
--- a/tests/test-api.js
+++ b/tests/test-api.js
@@ -2,6 +2,7 @@
 
 var o = require("../ospec/ospec")
 var browserMock = require("../test-utils/browserMock")
+var components = require("../test-utils/components")
 
 o.spec("api", function() {
 	var m
@@ -87,84 +88,90 @@ o.spec("api", function() {
 			o(root.firstChild.nodeName).equals("DIV")
 		})
 	})
-	o.spec("m.mount", function() {
-		o("works", function() {
-			var root = window.document.createElement("div")
-			m.mount(root, {view: function() {return m("div")}})
+	;[components[0]].forEach(function(cmp){
+		o.spec(cmp.kind, function(){
+			var createComponent = cmp.create
 
-			o(root.childNodes.length).equals(1)
-			o(root.firstChild.nodeName).equals("DIV")
+			o.spec("m.mount", function() {
+				o("works", function() {
+					var root = window.document.createElement("div")
+					m.mount(root, {view: function() {return m("div")}})
+
+					o(root.childNodes.length).equals(1)
+					o(root.firstChild.nodeName).equals("DIV")
+				})
+			})
+			o.spec("m.route", function() {
+				o("works", function(done) {
+					var root = window.document.createElement("div")
+					m.route(root, "/a", {
+						"/a": {view: function() {return m("div")}}
+					})
+
+					setTimeout(function() {
+						o(root.childNodes.length).equals(1)
+						o(root.firstChild.nodeName).equals("DIV")
+
+						done()
+					}, FRAME_BUDGET)
+				})
+				o("m.route.prefix", function(done) {
+					var root = window.document.createElement("div")
+					m.route.prefix("#")
+					m.route(root, "/a", {
+						"/a": {view: function() {return m("div")}}
+					})
+
+					setTimeout(function() {
+						o(root.childNodes.length).equals(1)
+						o(root.firstChild.nodeName).equals("DIV")
+
+						done()
+					}, FRAME_BUDGET)
+				})
+				o("m.route.get", function(done) {
+					var root = window.document.createElement("div")
+					m.route(root, "/a", {
+						"/a": {view: function() {return m("div")}}
+					})
+
+					setTimeout(function() {
+						o(m.route.get()).equals("/a")
+
+						done()
+					}, FRAME_BUDGET)
+				})
+				o("m.route.set", function(done, timeout) {
+					timeout(100)
+					var root = window.document.createElement("div")
+					m.route(root, "/a", {
+						"/:id": {view: function() {return m("div")}}
+					})
+
+					setTimeout(function() {
+						m.route.set("/b")
+						setTimeout(function() {
+							o(m.route.get()).equals("/b")
+
+							done()
+						}, FRAME_BUDGET)
+					}, FRAME_BUDGET)
+				})
+			})
+			o.spec("m.redraw", function() {
+				o("works", function(done) {
+					var count = 0
+					var root = window.document.createElement("div")
+					m.mount(root, {view: function() {count++}})
+					setTimeout(function() {
+						m.redraw()
+
+						o(count).equals(2)
+
+						done()
+					}, FRAME_BUDGET)
+				})
+			})
 		})
 	})
-	o.spec("m.route", function() {
-		o("works", function(done) {
-			var root = window.document.createElement("div")
-			m.route(root, "/a", {
-				"/a": {view: function() {return m("div")}}
-			})
-
-			setTimeout(function() {
-				o(root.childNodes.length).equals(1)
-				o(root.firstChild.nodeName).equals("DIV")
-
-				done()
-			}, FRAME_BUDGET)
-		})
-		o("m.route.prefix", function(done) {
-			var root = window.document.createElement("div")
-			m.route.prefix("#")
-			m.route(root, "/a", {
-				"/a": {view: function() {return m("div")}}
-			})
-
-			setTimeout(function() {
-				o(root.childNodes.length).equals(1)
-				o(root.firstChild.nodeName).equals("DIV")
-
-				done()
-			}, FRAME_BUDGET)
-		})
-		o("m.route.get", function(done) {
-			var root = window.document.createElement("div")
-			m.route(root, "/a", {
-				"/a": {view: function() {return m("div")}}
-			})
-
-			setTimeout(function() {
-				o(m.route.get()).equals("/a")
-
-				done()
-			}, FRAME_BUDGET)
-		})
-		o("m.route.set", function(done, timeout) {
-			timeout(100)
-			var root = window.document.createElement("div")
-			m.route(root, "/a", {
-				"/:id": {view: function() {return m("div")}}
-			})
-
-			setTimeout(function() {
-				m.route.set("/b")
-				setTimeout(function() {
-					o(m.route.get()).equals("/b")
-
-					done()
-				}, FRAME_BUDGET)
-			}, FRAME_BUDGET)
-		})
-	})
-	o.spec("m.redraw", function() {
-		o("works", function(done) {
-			var count = 0
-			var root = window.document.createElement("div")
-			m.mount(root, {view: function() {count++}})
-			setTimeout(function() {
-				m.redraw()
-
-				o(count).equals(2)
-
-				done()
-			}, FRAME_BUDGET)
-		})
-	})
-})
+})
\ No newline at end of file