diff --git a/src/browser/dom/performance.zig b/src/browser/dom/performance.zig
index 655df0c1b..6a971b4d5 100644
--- a/src/browser/dom/performance.zig
+++ b/src/browser/dom/performance.zig
@@ -203,22 +203,6 @@ test "Performance: now" {
     }
 }
 
-test "Browser.Performance.Mark" {
-    var runner = try testing.jsRunner(testing.tracking_allocator, .{});
-    defer runner.deinit();
-
-    try runner.testCases(&.{
-        .{ "let performance = window.performance", null },
-        .{ "performance instanceof Performance", "true" },
-
-        .{ "let mark1 = performance.mark(\"start\")", null },
-        .{ "mark1 instanceof PerformanceMark", "true" },
-        .{ "mark1.name", "start" },
-        .{ "mark1.entryType", "mark" },
-        .{ "mark1.duration", "0" },
-        .{ "mark1.detail", "null" },
-
-        .{ "let mark2 = performance.mark(\"start\", {startTime: 32939393.9})", null },
-        .{ "mark2.startTime", "32939393.9" },
-    }, .{});
+test "Browser: Performance.Mark" {
+    try testing.htmlRunner("dom/performance.html");
 }
diff --git a/src/browser/dom/performance_observer.zig b/src/browser/dom/performance_observer.zig
index bc2900864..5a53090d4 100644
--- a/src/browser/dom/performance_observer.zig
+++ b/src/browser/dom/performance_observer.zig
@@ -53,11 +53,6 @@ const Options = struct {
 };
 
 const testing = @import("../../testing.zig");
-test "Browser.DOM.PerformanceObserver" {
-    var runner = try testing.jsRunner(testing.tracking_allocator, .{});
-    defer runner.deinit();
-
-    try runner.testCases(&.{
-        .{ "PerformanceObserver.supportedEntryTypes.length", "0" },
-    }, .{});
+test "Browser: DOM.PerformanceObserver" {
+    try testing.htmlRunner("dom/performance_observer.html");
 }
diff --git a/src/browser/dom/processing_instruction.zig b/src/browser/dom/processing_instruction.zig
index 8165e69dc..1859e3f18 100644
--- a/src/browser/dom/processing_instruction.zig
+++ b/src/browser/dom/processing_instruction.zig
@@ -87,30 +87,6 @@ pub const ProcessingInstruction = struct {
 };
 
 const testing = @import("../../testing.zig");
-test "Browser.DOM.ProcessingInstruction" {
-    var runner = try testing.jsRunner(testing.tracking_allocator, .{});
-    defer runner.deinit();
-
-    try runner.testCases(&.{
-        .{ "let pi = document.createProcessingInstruction('foo', 'bar')", "undefined" },
-        .{ "pi.target", "foo" },
-        .{ "pi.data", "bar" },
-        .{ "pi.data = 'foo'", "foo" },
-        .{ "pi.data", "foo" },
-
-        .{ "let pi2 = pi.cloneNode()", "undefined" },
-        .{ "pi2.nodeType", "7" },
-    }, .{});
-
-    try runner.testCases(&.{
-        .{ "let pi11 = document.createProcessingInstruction('target1', 'data1');", "undefined" },
-        .{ "let pi12 = document.createProcessingInstruction('target2', 'data2');", "undefined" },
-        .{ "let pi13 = document.createProcessingInstruction('target1', 'data1');", "undefined" },
-        .{ "pi11.isEqualNode(pi11)", "true" },
-        .{ "pi11.isEqualNode(pi13)", "true" },
-        .{ "pi11.isEqualNode(pi12)", "false" },
-        .{ "pi12.isEqualNode(pi13)", "false" },
-        .{ "pi11.isEqualNode(document)", "false" },
-        .{ "document.isEqualNode(pi11)", "false" },
-    }, .{});
+test "Browser: DOM.ProcessingInstruction" {
+    try testing.htmlRunner("dom/processing_instruction.html");
 }
diff --git a/src/browser/dom/range.zig b/src/browser/dom/range.zig
index 9cd29abf9..7da6dbc93 100644
--- a/src/browser/dom/range.zig
+++ b/src/browser/dom/range.zig
@@ -385,44 +385,6 @@ fn compare(node_a: *parser.Node, offset_a: u32, node_b: *parser.Node, offset_b:
 }
 
 const testing = @import("../../testing.zig");
-test "Browser.Range" {
-    var runner = try testing.jsRunner(testing.tracking_allocator, .{});
-    defer runner.deinit();
-
-    try runner.testCases(&.{
-        // Test Range constructor
-        .{ "let range = new Range()", "undefined" },
-        .{ "range instanceof Range", "true" },
-        .{ "range instanceof AbstractRange", "true" },
-
-        // Test initial state - collapsed range
-        .{ "range.collapsed", "true" },
-        .{ "range.startOffset", "0" },
-        .{ "range.endOffset", "0" },
-        .{ "range.startContainer instanceof HTMLDocument", "true" },
-        .{ "range.endContainer instanceof HTMLDocument", "true" },
-
-        // Test document.createRange()
-        .{ "let docRange = document.createRange()", "undefined" },
-        .{ "docRange instanceof Range", "true" },
-        .{ "docRange.collapsed", "true" },
-    }, .{});
-
-    try runner.testCases(&.{
-        .{ "const container = document.getElementById('content');", null },
-
-        // Test text range
-        .{ "const commentNode = container.childNodes[7];", null },
-        .{ "commentNode.nodeValue", "comment" },
-        .{ "const textRange = document.createRange();", null },
-        .{ "textRange.selectNodeContents(commentNode)", "undefined" },
-        .{ "textRange.startOffset", "0" },
-        .{ "textRange.endOffset", "7" }, // length of `comment`
-
-        // Test Node range
-        .{ "const nodeRange = document.createRange();", null },
-        .{ "nodeRange.selectNodeContents(container)", "undefined" },
-        .{ "nodeRange.startOffset", "0" },
-        .{ "nodeRange.endOffset", "9" }, // length of container.childNodes
-    }, .{});
+test "Browser: Range" {
+    try testing.htmlRunner("dom/range.html");
 }
diff --git a/src/browser/dom/shadow_root.zig b/src/browser/dom/shadow_root.zig
index 76353b73f..f75aed6ff 100644
--- a/src/browser/dom/shadow_root.zig
+++ b/src/browser/dom/shadow_root.zig
@@ -96,60 +96,6 @@ pub const ShadowRoot = struct {
 };
 
 const testing = @import("../../testing.zig");
-test "Browser.DOM.ShadowRoot" {
-    defer testing.reset();
-
-    var runner = try testing.jsRunner(testing.tracking_allocator, .{ .html = 
-        \\ <div id=conflict>nope</div>
-    });
-    defer runner.deinit();
-
-    try runner.testCases(&.{
-        .{ "const div1 = document.createElement('div');", null },
-        .{ "let sr1 = div1.attachShadow({mode: 'open'})", null },
-        .{ "sr1.host == div1", "true" },
-        .{ "div1.attachShadow({mode: 'open'}) == sr1", "true" },
-        .{ "div1.shadowRoot == sr1", "true" },
-
-        .{ "try { div1.attachShadow({mode: 'closed'}) } catch (e) { e }", "Error: NotSupportedError" },
-
-        .{ " sr1.append(document.createElement('div'))", null },
-        .{ " sr1.append(document.createElement('span'))", null },
-        .{ "sr1.childElementCount", "2" },
-        // re-attaching clears it
-        .{ "div1.attachShadow({mode: 'open'}) == sr1", "true" },
-        .{ "sr1.childElementCount", "0" },
-    }, .{});
-
-    try runner.testCases(&.{
-        .{ "const div2 = document.createElement('di2');", null },
-        .{ "let sr2 = div2.attachShadow({mode: 'closed'})", null },
-        .{ "sr2.host == div2", "true" },
-        .{ "div2.shadowRoot", "null" }, // null when attached with 'closed'
-    }, .{});
-
-    try runner.testCases(&.{
-        .{ "sr2.getElementById('conflict')", "null" },
-        .{ "const n1 = document.createElement('div')", null },
-        .{ "n1.id = 'conflict'", null },
-        .{ "sr2.append(n1)", null },
-        .{ "sr2.getElementById('conflict') == n1", "true" },
-    }, .{});
-
-    try runner.testCases(&.{
-        .{ "const acss = sr2.adoptedStyleSheets", null },
-        .{ "acss.length", "0" },
-        .{ "acss.push(new CSSStyleSheet())", null },
-        .{ "sr2.adoptedStyleSheets.length", "1" },
-    }, .{});
-
-    try runner.testCases(&.{
-        .{ "sr1.innerHTML = '<p>hello</p>'", null },
-        .{ "sr1.innerHTML", "<p>hello</p>" },
-        .{ "sr1.querySelector('*')", "[object HTMLParagraphElement]" },
-
-        .{ "sr1.innerHTML = null", null },
-        .{ "sr1.innerHTML", "" },
-        .{ "sr1.querySelector('*')", "null" },
-    }, .{});
+test "Browser: DOM.ShadowRoot" {
+    try testing.htmlRunner("dom/shadow_root.html");
 }
diff --git a/src/browser/dom/text.zig b/src/browser/dom/text.zig
index b1334db5e..ac930cab6 100644
--- a/src/browser/dom/text.zig
+++ b/src/browser/dom/text.zig
@@ -56,31 +56,7 @@ pub const Text = struct {
     }
 };
 
-// Tests
-// -----
-
 const testing = @import("../../testing.zig");
-test "Browser.DOM.Text" {
-    var runner = try testing.jsRunner(testing.tracking_allocator, .{});
-    defer runner.deinit();
-
-    try runner.testCases(&.{
-        .{ "let t = new Text('foo')", "undefined" },
-        .{ "t.data", "foo" },
-
-        .{ "let emptyt = new Text()", "undefined" },
-        .{ "emptyt.data", "" },
-    }, .{});
-
-    try runner.testCases(&.{
-        .{ "let text = document.getElementById('link').firstChild", "undefined" },
-        .{ "text.wholeText === 'OK'", "true" },
-    }, .{});
-
-    try runner.testCases(&.{
-        .{ "text.data = 'OK modified'", "OK modified" },
-        .{ "let split = text.splitText('OK'.length)", "undefined" },
-        .{ "split.data === ' modified'", "true" },
-        .{ "text.data === 'OK'", "true" },
-    }, .{});
+test "Browser: DOM.Text" {
+    try testing.htmlRunner("dom/text.html");
 }
diff --git a/src/browser/dom/token_list.zig b/src/browser/dom/token_list.zig
index 6f12c4065..37a78df53 100644
--- a/src/browser/dom/token_list.zig
+++ b/src/browser/dom/token_list.zig
@@ -169,77 +169,7 @@ pub const Iterator = struct {
     }
 };
 
-// Tests
-// -----
-
 const testing = @import("../../testing.zig");
-test "Browser.DOM.TokenList" {
-    var runner = try testing.jsRunner(testing.tracking_allocator, .{});
-    defer runner.deinit();
-
-    try runner.testCases(&.{
-        .{ "let gs = document.getElementById('para-empty')", "undefined" },
-        .{ "let cl = gs.classList", "undefined" },
-        .{ "gs.className", "ok empty" },
-        .{ "cl.value", "ok empty" },
-        .{ "cl.length", "2" },
-        .{ "gs.className = 'foo bar baz'", "foo bar baz" },
-        .{ "gs.className", "foo bar baz" },
-        .{ "cl.length", "3" },
-        .{ "gs.className = 'ok empty'", "ok empty" },
-        .{ "cl.length", "2" },
-    }, .{});
-
-    try runner.testCases(&.{
-        .{ "let cl2 = gs.classList", "undefined" },
-        .{ "cl2.length", "2" },
-        .{ "cl2.item(0)", "ok" },
-        .{ "cl2.item(1)", "empty" },
-        .{ "cl2.contains('ok')", "true" },
-        .{ "cl2.contains('nok')", "false" },
-        .{ "cl2.add('foo', 'bar', 'baz')", "undefined" },
-        .{ "cl2.length", "5" },
-        .{ "cl2.remove('foo', 'bar', 'baz')", "undefined" },
-        .{ "cl2.length", "2" },
-    }, .{});
-
-    try runner.testCases(&.{
-        .{ "let cl3 = gs.classList", "undefined" },
-        .{ "cl3.toggle('ok')", "false" },
-        .{ "cl3.toggle('ok')", "true" },
-        .{ "cl3.length", "2" },
-    }, .{});
-
-    try runner.testCases(&.{
-        .{ "let cl4 = gs.classList", "undefined" },
-        .{ "cl4.replace('ok', 'nok')", "true" },
-        .{ "cl4.value", "empty nok" },
-        .{ "cl4.replace('nok', 'ok')", "true" },
-        .{ "cl4.value", "empty ok" },
-    }, .{});
-
-    try runner.testCases(&.{
-        .{ "let cl5 = gs.classList", "undefined" },
-        .{ "let keys = [...cl5.keys()]", "undefined" },
-        .{ "keys.length", "2" },
-        .{ "keys[0]", "0" },
-        .{ "keys[1]", "1" },
-
-        .{ "let values = [...cl5.values()]", "undefined" },
-        .{ "values.length", "2" },
-        .{ "values[0]", "empty" },
-        .{ "values[1]", "ok" },
-
-        .{ "let entries = [...cl5.entries()]", "undefined" },
-        .{ "entries.length", "2" },
-        .{ "entries[0]", "0,empty" },
-        .{ "entries[1]", "1,ok" },
-    }, .{});
-
-    try runner.testCases(&.{
-        .{ "let cl6 = gs.classList", "undefined" },
-        .{ "cl6.value = 'a  b  ccc'", "a  b  ccc" },
-        .{ "cl6.value", "a  b  ccc" },
-        .{ "cl6.toString()", "a  b  ccc" },
-    }, .{});
+test "Browser: DOM.TokenList" {
+    try testing.htmlRunner("dom/token_list.html");
 }
diff --git a/src/runtime/js.zig b/src/runtime/js.zig
index 190ac91f7..dcc92efdb 100644
--- a/src/runtime/js.zig
+++ b/src/runtime/js.zig
@@ -332,22 +332,22 @@ pub fn Env(comptime State: type, comptime WebApis: type) type {
         pub fn dumpMemoryStats(self: *Self) void {
             const stats = self.isolate.getHeapStatistics();
             std.debug.print(
-            \\ Total Heap Size: {d}
-            \\ Total Heap Size Executable: {d}
-            \\ Total Physical Size: {d}
-            \\ Total Available Size: {d}
-            \\ Used Heap Size: {d}
-            \\ Heap Size Limit: {d}
-            \\ Malloced Memory: {d}
-            \\ External Memory: {d}
-            \\ Peak Malloced Memory: {d}
-            \\ Number Of Native Contexts: {d}
-            \\ Number Of Detached Contexts: {d}
-            \\ Total Global Handles Size: {d}
-            \\ Used Global Handles Size: {d}
-            \\ Zap Garbage: {any}
-            \\
-            , .{stats.total_heap_size, stats.total_heap_size_executable, stats.total_physical_size, stats.total_available_size, stats.used_heap_size, stats.heap_size_limit, stats.malloced_memory, stats.external_memory, stats.peak_malloced_memory, stats.number_of_native_contexts, stats.number_of_detached_contexts, stats.total_global_handles_size, stats.used_global_handles_size, stats.does_zap_garbage});
+                \\ Total Heap Size: {d}
+                \\ Total Heap Size Executable: {d}
+                \\ Total Physical Size: {d}
+                \\ Total Available Size: {d}
+                \\ Used Heap Size: {d}
+                \\ Heap Size Limit: {d}
+                \\ Malloced Memory: {d}
+                \\ External Memory: {d}
+                \\ Peak Malloced Memory: {d}
+                \\ Number Of Native Contexts: {d}
+                \\ Number Of Detached Contexts: {d}
+                \\ Total Global Handles Size: {d}
+                \\ Used Global Handles Size: {d}
+                \\ Zap Garbage: {any}
+                \\
+            , .{ stats.total_heap_size, stats.total_heap_size_executable, stats.total_physical_size, stats.total_available_size, stats.used_heap_size, stats.heap_size_limit, stats.malloced_memory, stats.external_memory, stats.peak_malloced_memory, stats.number_of_native_contexts, stats.number_of_detached_contexts, stats.total_global_handles_size, stats.used_global_handles_size, stats.does_zap_garbage });
         }
 
         fn promiseRejectCallback(v8_msg: v8.C_PromiseRejectMessage) callconv(.c) void {
diff --git a/src/tests/dom/performance.html b/src/tests/dom/performance.html
new file mode 100644
index 000000000..1020ffaad
--- /dev/null
+++ b/src/tests/dom/performance.html
@@ -0,0 +1,15 @@
+<script src="../testing.js"></script>
+<script id=performance>
+  let performance = window.performance;
+  testing.expectEqual(true, performance instanceof Performance);
+
+  let mark1 = performance.mark("start");
+  testing.expectEqual(true, mark1 instanceof PerformanceMark);
+  testing.expectEqual('start', mark1.name);
+  testing.expectEqual('mark', mark1.entryType);
+  testing.expectEqual(0, mark1.duration);
+  testing.expectEqual(null, mark1.detail);
+
+  let mark2 = performance.mark("start", {startTime: 32939393.9});
+  testing.expectEqual(32939393.9, mark2.startTime);
+</script>
diff --git a/src/tests/dom/performance_observer.html b/src/tests/dom/performance_observer.html
new file mode 100644
index 000000000..4aff3f533
--- /dev/null
+++ b/src/tests/dom/performance_observer.html
@@ -0,0 +1,4 @@
+<script src="../testing.js"></script>
+<script id=performanceObserver>
+  testing.expectEqual(0, PerformanceObserver.supportedEntryTypes.length);
+</script>
diff --git a/src/tests/dom/processing_instruction.html b/src/tests/dom/processing_instruction.html
new file mode 100644
index 000000000..6925616d2
--- /dev/null
+++ b/src/tests/dom/processing_instruction.html
@@ -0,0 +1,21 @@
+<script src="../testing.js"></script>
+<script id=processingInstruction>
+  let pi = document.createProcessingInstruction('foo', 'bar');
+  testing.expectEqual('foo', pi.target);
+  testing.expectEqual('bar', pi.data);
+  pi.data = 'foo';
+  testing.expectEqual('foo', pi.data);
+
+  let pi2 = pi.cloneNode();
+  testing.expectEqual(7, pi2.nodeType);
+
+  let pi11 = document.createProcessingInstruction('target1', 'data1');
+  let pi12 = document.createProcessingInstruction('target2', 'data2');
+  let pi13 = document.createProcessingInstruction('target1', 'data1');
+  testing.expectEqual(true, pi11.isEqualNode(pi11));
+  testing.expectEqual(true, pi11.isEqualNode(pi13));
+  testing.expectEqual(false, pi11.isEqualNode(pi12));
+  testing.expectEqual(false, pi12.isEqualNode(pi13));
+  testing.expectEqual(false, pi11.isEqualNode(document));
+  testing.expectEqual(false, document.isEqualNode(pi11));
+</script>
diff --git a/src/tests/dom/range.html b/src/tests/dom/range.html
new file mode 100644
index 000000000..e76010a0a
--- /dev/null
+++ b/src/tests/dom/range.html
@@ -0,0 +1,40 @@
+<script src="../testing.js"></script>
+
+<div id=content><!-- hello world --><p>over 9000</p></div>
+
+<script id="constructor">
+  let range = new Range();
+  testing.expectEqual(true, range instanceof Range);
+  testing.expectEqual(true, range instanceof AbstractRange);
+
+// Test initial state - collapsed range
+  testing.expectEqual(true, range.collapsed);
+  testing.expectEqual(0, range.startOffset);
+  testing.expectEqual(0, range.endOffset);
+  testing.expectEqual(true, range.startContainer instanceof HTMLDocument);
+  testing.expectEqual(true, range.endContainer instanceof HTMLDocument);
+</script>
+
+<script id="createRange">
+  let docRange = document.createRange();
+  testing.expectEqual(true, docRange instanceof Range);
+  testing.expectEqual(true, docRange.collapsed);
+</script>
+
+<script id=textRange>
+  const container = $('#content');
+  const commentNode = container.childNodes[0];
+  testing.expectEqual(' hello world ', commentNode.nodeValue);
+
+  const textRange = document.createRange();
+  textRange.selectNodeContents(commentNode);
+  testing.expectEqual(0, textRange.startOffset);
+  testing.expectEqual(13, textRange.endOffset); // length of comment
+</script>
+
+<script id=nodeRange>
+  const nodeRange = document.createRange();
+  nodeRange.selectNodeContents(container);
+  testing.expectEqual(0, nodeRange.startOffset);
+  testing.expectEqual(2, nodeRange.endOffset); // length of container.childNodes
+</script>
diff --git a/src/tests/dom/shadow_root.html b/src/tests/dom/shadow_root.html
new file mode 100644
index 000000000..0072fa595
--- /dev/null
+++ b/src/tests/dom/shadow_root.html
@@ -0,0 +1,48 @@
+<div id=conflict>node</div>
+
+<script src="../testing.js"></script>
+<script id=shadow_root>
+  const div1 = document.createElement('div');
+  let sr1 = div1.attachShadow({mode: 'open'});
+  testing.expectEqual(div1, sr1.host);
+  testing.expectEqual(sr1, div1.attachShadow({mode: 'open'}));
+  testing.expectEqual(sr1, div1.shadowRoot);
+
+  testing.expectError('Error: NotSupportedError', () => {
+    div1.attachShadow({mode: 'closed'});
+  });
+
+  sr1.append(document.createElement('div'));
+  sr1.append(document.createElement('span'));
+  testing.expectEqual(2, sr1.childElementCount);
+
+  // re-attaching clears it
+  testing.expectEqual(sr1, div1.attachShadow({mode: 'open'}));
+  testing.expectEqual(0, sr1.childElementCount);
+
+
+  const div2 = document.createElement('di2');
+  let sr2 = div2.attachShadow({mode: 'closed'});
+  testing.expectEqual(div2, sr2.host);
+  testing.expectEqual(null, div2.shadowRoot) // null when attached with 'closed'
+
+
+  testing.expectEqual(null, sr2.getElementById('conflict'));
+  const n1 = document.createElement('div');
+  n1.id = 'conflict';
+  sr2.append(n1);
+  testing.expectEqual(n1, sr2.getElementById('conflict'));
+
+  const acss = sr2.adoptedStyleSheets;
+  testing.expectEqual(0, acss.length);
+  acss.push(new CSSStyleSheet());
+  testing.expectEqual(1, acss.length);
+
+  sr1.innerHTML = '<p>hello</p>';
+  testing.expectEqual('<p>hello</p>', sr1.innerHTML);
+  testing.expectEqual('[object HTMLParagraphElement]', sr1.querySelector('*').toString());
+
+  sr1.innerHTML = null;
+  testing.expectEqual('', sr1.innerHTML);
+  testing.expectEqual(null, sr1.querySelector('*'));
+  </script>
diff --git a/src/tests/dom/text.html b/src/tests/dom/text.html
new file mode 100644
index 000000000..812ca2585
--- /dev/null
+++ b/src/tests/dom/text.html
@@ -0,0 +1,18 @@
+<a id="link" href="foo" class="ok">OK</a>
+
+<script src="../testing.js"></script>
+<script id=text>
+  let t = new Text('foo');
+  testing.expectEqual('foo', t.data);
+
+  let emptyt = new Text();
+  testing.expectEqual('', emptyt.data);
+
+  let text = $('#link').firstChild;
+  testing.expectEqual('OK', text.wholeText);
+
+  text.data = 'OK modified';
+  let split = text.splitText('OK'.length);
+  testing.expectEqual(' modified', split.data);
+  testing.expectEqual('OK', text.data);
+</script>
diff --git a/src/tests/dom/token_list.html b/src/tests/dom/token_list.html
new file mode 100644
index 000000000..b07f0b6b8
--- /dev/null
+++ b/src/tests/dom/token_list.html
@@ -0,0 +1,63 @@
+<p id="para-empty" class="ok empty">
+
+<script src="../testing.js"></script>
+<script id=tokenList>
+  let gs = $('#para-empty');
+
+  let cl = gs.classList;
+  testing.expectEqual('ok empty', gs.className);
+  testing.expectEqual('ok empty', cl.value);
+  testing.expectEqual(2, cl.length);
+
+  gs.className = 'foo bar baz';
+  testing.expectEqual('foo bar baz', gs.className);
+  testing.expectEqual(3, cl.length);
+
+  gs.className = 'ok empty';
+  testing.expectEqual(2, cl.length);
+
+  let cl2 = gs.classList;
+  testing.expectEqual(2, cl2.length);
+  testing.expectEqual('ok', cl2.item(0));
+  testing.expectEqual('empty', cl2.item(1));
+  testing.expectEqual(true, cl2.contains('ok'));
+  testing.expectEqual(false, cl2.contains('nok'));
+
+  cl2.add('foo', 'bar', 'baz');
+  testing.expectEqual(5, cl2.length);
+
+  cl2.remove('foo', 'bar', 'baz');
+  testing.expectEqual(2, cl2.length);
+
+  let cl3 = gs.classList;
+  testing.expectEqual(false, cl3.toggle('ok'));
+  testing.expectEqual(true, cl3.toggle('ok'));
+  testing.expectEqual(2, cl3.length);
+
+  let cl4 = gs.classList;
+  testing.expectEqual(true, cl4.replace('ok', 'nok'));
+  testing.expectEqual("empty nok", cl4.value);
+  testing.expectEqual(true, cl4.replace('nok', 'ok'));
+  testing.expectEqual("empty ok", cl4.value);
+
+  let cl5 = gs.classList;
+  let keys = [...cl5.keys()];
+  testing.expectEqual(2, keys.length);
+  testing.expectEqual(0, keys[0]);
+  testing.expectEqual(1, keys[1]);
+
+  let values = [...cl5.values()];
+  testing.expectEqual(2, values.length);
+  testing.expectEqual('empty', values[0]);
+  testing.expectEqual('ok', values[1]);
+
+  let entries = [...cl5.entries()];
+  testing.expectEqual(2, entries.length);
+  testing.expectEqual([0, 'empty'], entries[0]);
+  testing.expectEqual([1, 'ok'], entries[1]);
+
+  let cl6 = gs.classList;
+  cl6.value = 'a  b  ccc';
+  testing.expectEqual('a  b  ccc', cl6.value);
+  testing.expectEqual('a  b  ccc', cl6.toString());
+</script>