Add a basic YAML processor. Much of the language is still unimplemented.

tests/utils/src/YamlTest.dart

+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#library('yamlTest');
+
+#import('../../../lib/unittest/unittest.dart');
+#import('../../../utils/yaml/yaml.dart', prefix: 'yaml');
+
+/** Constructs a new yaml.YamlMap, optionally from a normal Map. */
+Map yamlMap([Map from]) =>
+    from == null ? new yaml.YamlMap() : new yaml.YamlMap.from(from);
+
+/** Returns whether two lists have equivalent contents. */
+bool listDeepEquals(List list1, List list2) {
+  if (list1.length != list2.length) return false;
+
+  for (var i = 0; i < list1.length; i++) {
+    if (!deepEquals(list1[i], list2[i])) return false;
+  }
+
+  return true;
+}
+
+/** Returns whether two maps have equivalent contents. */
+bool mapDeepEquals(Map map1, Map map2) {
+  if (map1.length != map2.length) return false;
+
+  for (var key in map1.getKeys()) {
+    if (!map2.containsKey(key)) return false;
+    if (!deepEquals(map1[key], map2[key])) return false;
+  }
+
+  return true;
+}
+
+/**
+ * Returns whether two doubles are equal. This differs from `d1 == d2` in that
+ * it considers NaN to be equal to itself.
+ */
+bool doubleEquals(double d1, double d2) {
+  if (d1.isNaN() && d2.isNaN()) return true;
+  return d1 == d2;
+}
+
+/** Returns whether two objects are structurally equivalent. */
+bool deepEquals(obj1, obj2) {
+  if (obj1 is List && obj2 is List) return listDeepEquals(obj1, obj2);
+  if (obj1 is Map && obj2 is Map) return mapDeepEquals(obj1, obj2);
+  if (obj1 is double && obj2 is double) return doubleEquals(obj1, obj2);
+  return obj1 == obj2;
+}
+
+/**
+ * Asserts that a string containing a single YAML document produces a given
+ * value when loaded.
+ */
+expectYamlLoads(expected, String source) {
+  var actual = yaml.load(source);
+  Expect.isTrue(deepEquals(expected, actual), 
+      'expectYamlLoads(expected: <$expected>, actual: <$actual>)');
+}
+
+/**
+ * Asserts that a string containing a stream of YAML documents produces a given
+ * list of values when loaded.
+ */
+expectYamlStreamLoads(List expected, String source) {
+  var actual = yaml.loadStream(source);
+  Expect.isTrue(deepEquals(expected, actual), 
+      'expectYamlStreamLoads(expected: <$expected>, actual: <$actual>)');
+}
+
+main() {
+  var infinity = Math.parseDouble("Infinity");
+  var nan = Math.parseDouble("NaN");
+
+  group('YamlMap', () {
+    group('accepts as a key', () {
+      _expectKeyWorks(keyFn()) {
+        var map = yamlMap();
+        map[keyFn()] = 5;
+        Expect.isTrue(map.containsKey(keyFn()));
+        Expect.equals(5, map[keyFn()]);
+      }
+
+      test('null', () => _expectKeyWorks(() => null));
+      test('true', () => _expectKeyWorks(() => true));
+      test('false', () => _expectKeyWorks(() => false));
+      test('a list', () => _expectKeyWorks(() => [1, 2, 3]));
+      test('a map', () => _expectKeyWorks(() => {'foo': 'bar'}));
+      test('a YAML map', () => _expectKeyWorks(() => yamlMap({'foo': 'bar'})));
+    });
+
+    test('works as a hash key', () {
+      var normalMap = new Map();
+      normalMap[yamlMap({'foo': 'bar'})] = 'baz';
+      Expect.isTrue(normalMap.containsKey(yamlMap({'foo': 'bar'})));
+      Expect.equals('baz', normalMap[yamlMap({'foo': 'bar'})]);
+    });
+  });
+
+  // The following tests are all taken directly from the YAML spec
+  // (http://www.yaml.org/spec/1.2/spec.html). Most of them are code examples
+  // that are directly included in the spec, but additional tests are derived
+  // from the prose.
+
+  // A few examples from the spec are deliberately excluded, because they test
+  // features that this implementation doesn't intend to support (character
+  // encoding detection and user-defined tags). More tests are commented out,
+  // because they're intended to be supported but not yet implemented.
+
+  // Chapter 2 is just a preview of various Yaml documents. It's probably not
+  // necessary to test its examples, but it would be nice to test everything in
+  // the spec.
+  group('2.1: Collections', () {
+    test('[Example 2.1]', () {
+      expectYamlLoads(["Mark McGwire", "Sammy Sosa", "Ken Griffey"], """
+- Mark McGwire
+- Sammy Sosa
+- Ken Griffey
+""");
+    });
+
+    test('[Example 2.2]', () {
+      expectYamlLoads({"hr": 65, "avg": 0.278, "rbi": 147}, """
+hr:  65    # Home runs
+avg: 0.278 # Batting average
+rbi: 147   # Runs Batted In
+""");
+    });
+
+    test('[Example 2.3]', () {
+      expectYamlLoads({
+        "american": ["Boston Red Sox", "Detroit Tigers", "New York Yankees"],
+        "national": ["New York Mets", "Chicago Cubs", "Atlanta Braves"],
+      }, """
+american:
+  - Boston Red Sox
+  - Detroit Tigers
+  - New York Yankees
+national:
+  - New York Mets
+  - Chicago Cubs
+  - Atlanta Braves
+""");
+    });
+
+    test('[Example 2.4]', () {
+      expectYamlLoads([
+        {"name": "Mark McGwire", "hr": 65, "avg": 0.278},
+        {"name": "Sammy Sosa", "hr": 63, "avg": 0.288},
+      ], """
+-
+  name: Mark McGwire
+  hr:   65
+  avg:  0.278
+-
+  name: Sammy Sosa
+  hr:   63
+  avg:  0.288
+""");
+    });
+
+//     test('[Example 2.5]', () {
+//       expectYamlLoads([
+//         ["name", "hr", "avg"],
+//         ["Mark McGwire", 65, 0.278],
+//         ["Sammy Sosa", 63, 0.288]
+//       ], """
+// - [name        , hr, avg  ]
+// - [Mark McGwire, 65, 0.278]
+// - [Sammy Sosa  , 63, 0.288]
+// """);
+//     });
+
+//     test('[Example 2.6]', () {
+//       expectYamlLoads({
+//         "Mark McGwire": {"hr": 65, "avg": 0.278},
+//         "Sammy Sosa": {"hr": 63, "avg": 0.288}
+//       }, """
+// Mark McGwire: {hr: 65, avg: 0.278}
+// Sammy Sosa: {
+//     hr: 63,
+//     avg: 0.288
+//   }
+// """);
+//     });
+  });
+
+  group('2.2: Structures', () {
+    test('[Example 2.7]', () {
+      expectYamlStreamLoads([
+        ["Mark McGwire", "Sammy Sosa", "Ken Griffey"],
+        ["Chicago Cubs", "St Louis Cardinals"]
+      ], """
+# Ranking of 1998 home runs
+---
+- Mark McGwire
+- Sammy Sosa
+- Ken Griffey
+
+# Team ranking
+---
+- Chicago Cubs
+- St Louis Cardinals
+""");
+    });
+
+    test('[Example 2.8]', () {
+      expectYamlStreamLoads([
+        {"time": "20:03:20", "player": "Sammy Sosa", "action": "strike (miss)"},
+        {"time": "20:03:47", "player": "Sammy Sosa", "action": "grand slam"},
+      ], """
+---
+time: 20:03:20
+player: Sammy Sosa
+action: strike (miss)
+...
+---
+time: 20:03:47
+player: Sammy Sosa
+action: grand slam
+...
+""");
+    });
+
+    test('[Example 2.9]', () {
+      expectYamlLoads({
+        "hr": ["Mark McGwire", "Sammy Sosa"],
+        "rbi": ["Sammy Sosa", "Ken Griffey"]
+      }, """
+---
+hr: # 1998 hr ranking
+  - Mark McGwire
+  - Sammy Sosa
+rbi:
+  # 1998 rbi ranking
+  - Sammy Sosa
+  - Ken Griffey
+""");
+    });
+
+//     test('[Example 2.10]', () {
+//       expectYamlLoads({
+//         "hr": ["Mark McGwire", "Sammy Sosa"],
+//         "rbi": ["Sammy Sosa", "Ken Griffey"]
+//       }, """
+// ---
+// hr:
+//   - Mark McGwire
+//   # Following node labeled SS
+//   - &SS Sammy Sosa
+// rbi:
+//   - *SS # Subsequent occurrence
+//   - Ken Griffey
+// """);
+//     });
+
+//     test('[Example 2.11]', () {
+//       var doc = yamlMap();
+//       doc[["Detroit Tigers", "Chicago cubs"]] = ["2001-07-23"];
+//       doc[["New York Yankees", "Atlanta Braves"]] =
+//         ["2001-07-02", "2001-08-12", "2001-08-14"];
+//       expectYamlLoads(doc, """
+// ? - Detroit Tigers
+//   - Chicago cubs
+// :
+//   - 2001-07-23
+
+// ? [ New York Yankees,
+//     Atlanta Braves ]
+// : [ 2001-07-02, 2001-08-12,
+//     2001-08-14 ]
+// """);
+//     });
+
+    test('[Example 2.12]', () {
+      expectYamlLoads([
+        {"item": "Super Hoop", "quantity": 1},
+        {"item": "Basketball", "quantity": 4},
+        {"item": "Big Shoes", "quantity": 1},
+      ], """
+---
+# Products purchased
+- item    : Super Hoop
+  quantity: 1
+- item    : Basketball
+  quantity: 4
+- item    : Big Shoes
+  quantity: 1
+""");
+    });
+  });
+
+  group('2.3: Scalars', () {
+//     test('[Example 2.13]', () {
+//       expectYamlLoads("""
+//   \//||\/||
+//   // ||  ||__
+// """.trim(), """
+// # ASCII Art
+// --- |
+//   \//||\/||
+//   // ||  ||__
+// """);
+//     });
+
+//     test('[Example 2.14]', () {
+//       expectYamlLoads("Mark McGwire's year was crippled by a knee injury.", """
+// --- >
+//   Mark McGwire's
+//   year was crippled
+//   by a knee injury.
+// """);
+//     });
+
+//     test('[Example 2.15]', () {
+//       expectYamlLoads("""
+// Sammy Sosa completed another
+// fine season with great stats.
+
+//   63 Home Runs
+//   0.288 Batting Average
+
+// What a year!
+// """, """
+// >
+//  Sammy Sosa completed another
+//  fine season with great stats.
+
+//    63 Home Runs
+//    0.288 Batting Average
+
+//  What a year!
+// """);
+//     });
+
+//     test('[Example 2.16]', () {
+//       expectYamlLoads({
+//         "name": "Mark McGwire",
+//         "accomplishment": "Mark set a major league home run record in 1998.",
+//         "stats": "65 Home Runs\n0.278 Batting Average"
+//       }, """
+// name: Mark McGwire
+// accomplishment: >
+//   Mark set a major league
+//   home run record in 1998.
+// stats: |
+//   65 Home Runs
+//   0.278 Batting Average
+// """);
+//     });
+
+//     test('[Example 2.17]', () {
+//       expectYamlLoads({
+//         "unicode": "Sosa did fine.\u263A",
+//         "control": "\b1998\t1999\t2000\n",
+//         "hex esc": "\r\n is \r\n",
+//         "single": '"Howdy!" he cried.',
+//         "quoted": " # Not a 'comment'.",
+//         "tie-fighter": "|\-*-/|"
+//       }, """
+// unicode: "Sosa did fine.\u263A"
+// control: "\b1998\t1999\t2000\n"
+// hex esc: "\x0d\x0a is \r\n"
+
+// single: '"Howdy!" he cried.'
+// quoted: ' # Not a ''comment''.'
+// tie-fighter: '|\-*-/|'
+// """);
+//     });
+
+//     test('[Example 2.18]', () {
+//       expectYamlLoads({
+//         "plain": "This unquoted scalar spans many lines.",
+//         "quoted": "So does this quoted scalar.\n"
+//       }, """
+// plain:
+//   This unquoted scalar
+//   spans many lines.
+
+// quoted: "So does this
+//   quoted scalar.\n"
+// """);
+//     });
+  });
+
+  group('2.4: Tags', () {
+    test('[Example 2.19]', () {
+      expectYamlLoads({
+        "canonical": 12345,
+        "decimal": 12345,
+        "octal": 12,
+        "hexadecimal": 12
+      }, """
+canonical: 12345
+decimal: +12345
+octal: 0o14
+hexadecimal: 0xC
+""");
+    });
+
+    test('[Example 2.20]', () {
+      expectYamlLoads({
+        "canonical": 1230.15,
+        "exponential": 1230.15,
+        "fixed": 1230.15,
+        "negative infinity": -infinity,
+        "not a number": nan
+      }, """
+canonical: 1.23015e+3
+exponential: 12.3015e+02
+fixed: 1230.15
+negative infinity: -.inf
+not a number: .NaN
+""");
+    });
+
+//     test('[Example 2.21]', () {
+//       var doc = yamlMap({
+//         "booleans": [true, false],
+//         "string": "012345"
+//       });
+//       doc[null] = null;
+//       expectYamlLoads(doc, """
+// null:
+// booleans: [ true, false ]
+// string: '012345'
+// """);
+//     });
+
+    // Examples 2.22 through 2.26 test custom tag URIs, which this
+    // implementation currently doesn't plan to support.
+  });
+
+  group('2.5 Full Length Example', () {
+    // Example 2.27 tests custom tag URIs, which this implementation currently
+    // doesn't plan to support.
+
+//     test('[Example 2.28]', () {
+//       expectYamlStreamLoads([
+//         {
+//           "Time": "2001-11-23 15:01:42 -5",
+//           "User": "ed",
+//           "Warning": "This is an error message for the log file"
+//         },
+//         {
+//           "Time": "2001-11-23 15:02:31 -5",
+//           "User": "ed",
+//           "Warning": "A slightly different error message."
+//         },
+//         {
+//           "Date": "2001-11-23 15:03:17 -5",
+//           "User": "ed",
+//           "Fatal": 'Unknown variable "bar"',
+//           "Stack": [
+//             {
+//               "file": "TopClass.py",
+//               "line": 23,
+//               "code": 'x = MoreObject("345\n")\n'
+//             },
+//             {"file": "MoreClass.py", "line": 58, "code": "foo = bar"}
+//           ]
+//         }
+//       ], """
+// ---
+// Time: 2001-11-23 15:01:42 -5
+// User: ed
+// Warning:
+//   This is an error message
+//   for the log file
+// ---
+// Time: 2001-11-23 15:02:31 -5
+// User: ed
+// Warning:
+//   A slightly different error
+//   message.
+// ---
+// Date: 2001-11-23 15:03:17 -5
+// User: ed
+// Fatal:
+//   Unknown variable "bar"
+// Stack:
+//   - file: TopClass.py
+//     line: 23
+//     code: |
+//       x = MoreObject("345\n")
+//   - file: MoreClass.py
+//     line: 58
+//     code: |-
+//       foo = bar
+// """);
+//     });
+  });
+
+  // Chapter 3 just talks about the structure of loading and dumping Yaml.
+  // Chapter 4 explains conventions used in the spec.
+
+  // Chapter 5: Characters
+  group('5.1: Character Set', () {
+    expectAllowsCharacter(int charCode) {
+      var char = new String.fromCharCodes([charCode]);
+      expectYamlLoads('The character "$char" is allowed',
+          'The character "$char" is allowed');
+    }
+
+    expectAllowsQuotedCharacter(int charCode) {
+      var char = new String.fromCharCodes([charCode]);
+      expectYamlLoads("The character '$char' is allowed",
+          '"The character \'$char\' is allowed"');
+    }
+
+    expectDisallowsCharacter(int charCode) {
+      var char = new String.fromCharCodes([charCode]);
+      Expect.throws(() => yaml.load('The character "$char" is disallowed'));
+    }
+
+    test("doesn't include C0 control characters", () {
+      expectDisallowsCharacter(0x0);
+      expectDisallowsCharacter(0x8);
+      expectDisallowsCharacter(0x1F);
+    });
+
+    test("includes TAB", () => expectAllowsCharacter(0x9));
+    test("doesn't include DEL", () => expectDisallowsCharacter(0x7F));
+
+    test("doesn't include C1 control characters", () {
+      expectDisallowsCharacter(0x80);
+      expectDisallowsCharacter(0x8A);
+      expectDisallowsCharacter(0x9F);
+    });
+
+    test("includes NEL", () => expectAllowsCharacter(0x85));
+
+    group("within quoted strings", () {
+      // test("includes DEL", () => expectAllowsQuotedCharacter(0x7F));
+      // test("includes C1 control characters", () {
+      //   expectAllowsQuotedCharacter(0x80);
+      //   expectAllowsQuotedCharacter(0x8A);
+      //   expectAllowsQuotedCharacter(0x9F);
+      // });
+    });
+  });
+
+  // Skipping section 5.2 (Character Encodings), since at the moment the module
+  // assumes that the client code is providing it with a string of the proper
+  // encoding.
+
+  group('5.3: Indicator Characters', () {
+//     test('[Example 5.3]', () {
+//       expectYamlLoads({
+//         'sequence': ['one', 'two'],
+//         'mapping': {'sky': 'blue', 'sea': 'green'}
+//       }, """
+// sequence:
+// - one
+// - two
+// mapping:
+//   ? sky
+//   : blue
+//   sea : green
+// """);
+//     });
+
+//     test('[Example 5.4]', () {
+//       expectYamlLoads({
+//         'sequence': ['one', 'two'],
+//         'mapping': {'sky': 'blue', 'sea': 'green'}
+//       }, """
+// sequence: [ one, two, ]
+// mapping: { sky: blue, sea: green }
+// """);
+//     });
+
+    test('[Example 5.5]', () => expectYamlLoads(null, "# Comment only."));
+
+    // Skipping 5.6 because it uses an undefined tag.
+
+//     test('[Example 5.7]', () {
+//       expectYamlLoads({
+//         'literal': "some text\n",
+//         'folded': "some\ntext\n"
+//       }, """
+// literal: |
+//   some
+//   text
+// folded: >
+//   some
+//   text
+// """);
+//     });
+
+//     test('[Example 5.8]', () {
+//       expectYamlLoads({
+//         'single': "text",
+//         'double': "text"
+//       }, """
+// single: 'text'
+// double: "text"
+// """);
+//     });
+
+//     test('[Example 5.9]', () {
+//       expectYamlLoads("text", """
+// %YAML 1.2
+// --- text
+// """);
+//     });
+
+    test('[Example 5.10]', () {
+      Expect.throws(() => yaml.load("commercial-at: @text"));
+      Expect.throws(() => yaml.load("commercial-at: `text"));
+    });
+  });
+
+  group('5.4: Line Break Characters', () {
+    group('include', () {
+      test('\\n', () => expectYamlLoads([1, 2], "- 1\n- 2"));
+      test('\\r', () => expectYamlLoads([1, 2], "- 1\r- 2"));
+    });
+
+    group('do not include', () {
+      test('form feed', () => Expect.throws(() => yaml.load("- 1\x0C- 2")));
+      test('NEL', () => expectYamlLoads(["1\x85- 2"], "- 1\x85- 2"));
+      test('0x2028', () => expectYamlLoads(["1\u2028- 2"], "- 1\u2028- 2"));
+      test('0x2029', () => expectYamlLoads(["1\u2029- 2"], "- 1\u2029- 2"));
+    });
+
+    group('in a scalar context must be normalized', () {
+      // test("from \\r to \\n", () =>
+      //       expectYamlLoads("foo\nbar", '- |\n  foo\r  bar'));
+      // test("from \\r\\n to \\n", () =>
+      //       expectYamlLoads("foo\nbar", '- |\n  foo\r\n  bar'));
+    });
+
+//     test('[Example 5.11]', () {
+//       expectYamlLoads("""
+// Line break (no glyph)
+// Line break (glyphed)
+// """, """
+// |
+//   Line break (no glyph)
+//   Line break (glyphed)
+// """);
+//     });
+  });
+
+  group('5.5: White Space Characters', () {
+//     test('[Example 5.12]', () {
+//       expectYamlLoads({
+//         "quoted": "Quoted \t",
+//         "block": 'void main() {\n\tprintf("Hello, world!\\n");\n}\n'
+//       }, """
+// # Tabs and spaces
+// quoted: "Quoted \t"
+// block:\t|
+//   void main() {
+//   \tprintf("Hello, world!\\n");
+//   }
+// """);
+//     });
+  });
+
+  group('5.7: Escaped Characters', () {
+//     test('[Example 5.13]', () {
+//       expectYamlLoads("""
+// Fun with \x5C
+// \x22 \x07 \x08 \x1B \x0C
+// \x0A \x0D \x09 \x0B \x00
+// \x20 \xA0 \x85 \u2028 \u2029
+// A A A
+// """.trim(), '''
+// "Fun with \\\\
+// \\" \\a \\b \\e \\f \\
+// \\n \\r \\t \\v \\0 \\
+// \\  \\_ \\N \\L \\P \\
+// \\x41 \\u0041 \\U00000041"
+// ''');
+//     });
+
+    // test('[Example 5.14]', () {
+    //   Expect.throws(() => yaml.load('Bad escape: "\\c"'));
+    //   Expect.throws(() => yaml.load('Bad escape: "\\xq-"'));
+    // });
+  });
+
+  // Chapter 6: Basic Structures
+  group('6.1: Indentation Spaces', () {
+    test('may not include TAB characters', () {
+      Expect.throws(() => yaml.load("""
+-
+\t- foo
+\t- bar
+"""));
+    });
+
+    test('must be the same for all sibling nodes', () {
+      Expect.throws(() => yaml.load("""
+-
+  - foo
+ - bar
+"""));
+    });
+
+    test('may be different for the children of sibling nodes', () {
+      expectYamlLoads([["foo"], ["bar"]], """
+-
+  - foo
+-
+ - bar
+""");
+    });
+
+//     test('[Example 6.1]', () {
+//       expectYamlLoads({
+//         "Not indented": {
+//           "By one space": "By four\n  spaces\n",
+//           "Flow style": [
+//             "By two",
+//             "Also by two",
+//             "Still by two"
+//           ]
+//         }
+//       }, """
+//   # Leading comment line spaces are
+//    # neither content nor indentation.
+    
+// Not indented:
+//  By one space: |
+//     By four
+//       spaces
+//  Flow style: [    # Leading spaces
+//    By two,        # in flow style
+//   Also by two,    # are neither
+//   \tStill by two   # content nor
+//     ]             # indentation.
+// """);
+//     });
+
+//     test('[Example 6.2]', () {
+//       expectYamlLoads({'a': ['b', ['c', 'd']]}, """
+// ? a
+// : -\tb
+//   -  -\tc
+//      - d
+// """);
+//     });
+  });
+
+  group('6.2: Separation Spaces', () {
+    test('[Example 6.3]', () {
+      expectYamlLoads([{'foo': 'bar'}, ['baz', 'baz']], """
+- foo:\t bar
+- - baz
+  -\tbaz
+""");
+    });
+  });
+
+  group('6.3: Line Prefixes', () {
+//     test('[Example 6.4]', () {
+//       expectYamlLoads({
+//         "plain": "text lines",
+//         "quoted": "text lines",
+//         "block": "text\n \tlines\n"
+//       }, """
+// plain: text
+//   lines
+// quoted: "text
+//   \tlines"
+// block: |
+//   text
+//    \tlines
+// """);
+//     });
+  });
+
+  group('6.4: Empty Lines', () {
+//     test('[Example 6.5]', () {
+//       expectYamlLoads({
+//         "Folding": "Empty line\nas a line feed",
+//         "Chomping": "Clipped empty lines\n",
+//       }, """
+// Folding:
+//   "Empty line
+//    \t
+//   as a line feed"
+// Chomping: |
+//   Clipped empty lines
+//  """);
+//     });
+  });
+
+  group('6.5: Line Folding', () {
+//     test('[Example 6.6]', () {
+//       expectYamlLoads("trimmed\n\n\nas space", """
+// >-
+//   trimmed
+  
+ 
+
+//   as
+//   space
+// """.trim());
+//     });
+
+//     test('[Example 6.7]', () {
+//       expectYamlLoads("foo \n\n\t bar\n\nbaz\n", """
+// >
+//   foo 
+ 
+//   \t bar
+
+//   baz
+// """);
+//     });
+
+//     test('[Example 6.8]', () {
+//       expectYamlLoads(" foo\nbar\nbaz ", """
+// "
+//   foo 
+ 
+//   \t bar
+
+//   baz
+// "
+// """);
+//     });
+  });
+
+  group('6.6: Comments', () {
+    test('must be separated from other tokens by white space characters', () {
+      expectYamlLoads("foo#bar", "foo#bar");
+      expectYamlLoads("foo:#bar", "foo:#bar");
+      expectYamlLoads("-#bar", "-#bar");
+    });
+
+    test('[Example 6.9]', () {
+      expectYamlLoads({'key': 'value'}, """
+key:    # Comment
+  value
+""");
+    });
+
+    group('outside of scalar content', () {
+      test('may appear on a line of their own', () {
+        expectYamlLoads([1, 2], """
+- 1
+# Comment
+- 2
+""");
+      });
+
+      test('are independent of indentation level', () {
+        expectYamlLoads([[1, 2]], """
+-
+  - 1
+ # Comment
+  - 2
+""");
+      });
+
+      test('include lines containing only white space characters', () {
+        expectYamlLoads([1, 2], """
+- 1
+  \t  
+- 2
+""");
+      });
+    });
+
+    group('within scalar content', () {
+//       test('may not appear on a line of their own', () {
+//         expectYamlLoads("foo\n# not comment\nbar\n", """
+// - |
+//   foo
+//   # not comment
+//   bar
+// """);        
+//       });
+
+//       test("don't include lines containing only white space characters", () {
+//         expectYamlLoads("foo\n  \t   \nbar\n", """
+// - |
+//   foo
+//     \t   
+//   bar
+// """);        
+//       });
+    });
+
+    test('[Example 6.10]', () {
+      expectYamlLoads(null, """
+  # Comment
+   
+""");
+    });
+
+    test('[Example 6.11]', () {
+      expectYamlLoads({'key': 'value'}, """
+key:    # Comment
+        # lines
+  value
+""");
+    });
+
+    group('ending a block scalar header', () {
+//       test('may not be followed by additional comment lines', () {
+//         expectYamlLoads("# not comment\nfoo\n", """
+// - | # comment
+//     # not comment
+//     foo
+// """);
+//       });
+    });
+  });
+
+  group('6.7: Separation Lines', () {
+//     test('may not be used within implicit keys', () {
+//       Expect.throws(() => yaml.load("""
+// [1,
+//  2]: 3
+// """));
+//     });
+
+//     test('[Example 6.12]', () {
+//       var doc = yamlMap();
+//       doc[{'first': 'Sammy', 'last': 'Sosa'}] = {
+//         'hr': 65,
+//         'avg': 0.278
+//       };
+//       expectYamlLoads(doc, """
+// { first: Sammy, last: Sosa }:
+// # Statistics:
+//   hr:  # Home runs
+//      65
+//   avg: # Average
+//    0.278
+// """);
+//     });
+  });
+
+  group('6.8: Directives', () {
+//     // TODO(nweiz): assert that this produces a warning
+//     test('[Example 6.13]', () {
+//       expectYamlLoads("foo", """
+// %FOO  bar baz # Should be ignored
+//                # with a warning.
+// --- "foo"
+// """);
+//     });
+
+//     // TODO(nweiz): assert that this produces a warning
+//     test('[Example 6.14]', () {
+//       expectYamlLoads("foo", """
+// %YAML 1.3 # Attempt parsing
+//            # with a warning
+// ---
+// "foo"
+// """);
+//     });
+
+//     test('[Example 6.15]', () {
+//       Expect.throws(() => yaml.load("""
+// %YAML 1.2
+// %YAML 1.1
+// foo
+// """));
+//     });
+
+//     test('[Example 6.16]', () {
+//       expectYamlLoads("foo", """
+// %TAG !yaml! tag:yaml.org,2002:
+// ---
+// !yaml!str "foo"
+// """);
+//     });
+
+//     test('[Example 6.17]', () {
+//       Expect.throws(() => yaml.load("""
+// %TAG ! !foo
+// %TAG ! !foo
+// bar
+// """));
+//     });
+
+    // Examples 6.18 through 6.22 test custom tag URIs, which this
+    // implementation currently doesn't plan to support.
+  });
+
+  group('6.9: Node Properties', () {
+//     test('may be specified in any order', () {
+//       expectYamlLoads(["foo", "bar"], """
+// - !!str &a1 foo
+// - &a2 !!str bar
+// """);
+//     });
+
+//     test('[Example 6.23]', () {
+//       expectYamlLoads({
+//         "foo": "bar",
+//         "baz": "foo"
+//       }, """
+// !!str &a1 "foo":
+//   !!str bar
+// &a2 baz : *a1
+// """);
+//     });
+
+//     // Example 6.24 tests custom tag URIs, which this implementation currently
+//     // doesn't plan to support.
+
+//     test('[Example 6.25]', () {
+//       Expect.throws(() => yaml.load("- !<!> foo"));
+//       Expect.throws(() => yaml.load("- !<\$:?> foo"));
+//     });
+
+//     // Examples 6.26 and 6.27 test custom tag URIs, which this implementation
+//     // currently doesn't plan to support.
+
+//     test('[Example 6.28]', () {
+//       expectYamlLoads(["12", 12, "12"], """
+// # Assuming conventional resolution:
+// - "12"
+// - 12
+// - ! 12
+// """);
+//     });
+
+//     test('[Example 6.29]', () {
+//       expectYamlLoads({
+//         "First occurrence": "Value",
+//         "Second occurrence": "anchor"
+//       }, """
+// First occurrence: &anchor Value
+// Second occurrence: *anchor
+// """);
+//     });
+  });
+
+  // Chapter 7: Flow Styles
+  group('7.1: Alias Nodes', () {
+//     test("must not use an anchor that doesn't previously occur", () {
+//       Expect.throws(() => yaml.load("""
+// - *anchor
+// - &anchor foo
+// """));
+//     });
+
+//     test("don't have to exist for a given anchor node", () {
+//       expectYamlLoads(["foo"], "- &anchor foo");
+//     });
+
+//     group('must not specify', () {
+//       test('tag properties', () => Expect.throws(() => yaml.load("""
+// - &anchor foo
+// - !str *anchor
+// """)));
+
+//       test('anchor properties', () => Expect.throws(() => yaml.load("""
+// - &anchor foo
+// - &anchor2 *anchor
+// """)));
+
+//       test('content', () => Expect.throws(() => yaml.load("""
+// - &anchor foo
+// - *anchor bar
+// """)));
+//     });
+
+//     test('must preserve structural equality', () {
+//       var doc = yaml.load("""
+// anchor: &anchor [a, b, c]
+// alias: *anchor
+// """);
+//       var anchorList = doc['anchor'];
+//       var aliasList = doc['alias'];
+//       Expect.isTrue(anchorList === aliasList);
+//       anchorList.add('d');
+//       Expect.listEquals(['a', 'b', 'c', 'd'], aliasList);
+
+//       doc = yaml.load("""
+// ? &anchor [a, b, c]
+// : ? *anchor
+//   : bar
+// """);
+//       anchorList = doc.getKeys()[0];
+//       aliasList = doc[['a', 'b', 'c']].getKeys()[0];
+//       Expect.isTrue(anchorList === aliasList);
+//       anchorList.add('d');
+//       Expect.listEquals(['a', 'b', 'c', 'd'], aliasList);
+//     });
+
+//     test('[Example 7.1]', () {
+//       expectYamlLoads({
+//         "First occurence": "Foo",
+//         "Second occurence": "Foo",
+//         "Override anchor": "Bar",
+//         "Reuse anchor": "Bar",
+//       }, """
+// First occurrence: &anchor Foo
+// Second occurrence: *anchor
+// Override anchor: &anchor Bar
+// Reuse anchor: *anchor
+// """);
+//     });
+  });
+
+  group('7.2: Empty Nodes', () {
+
+//     test('[Example 7.2]', () {
+//       expectYamlLoads({
+//         "foo": "",
+//         "": "bar"
+//       }, """
+// {
+//   foo : !!str,
+//   !!str : bar,
+// }
+// """);
+//     });
+
+//     test('[Example 7.3]', () {
+//       var doc = yamlMap({"foo": null});
+//       doc[null] = "bar";
+//       expectYamlLoads(doc, """
+// {
+//   ? foo :,
+//   : bar,
+// }
+// """);
+//     });
+  });
+
+  group('7.3: Flow Scalar Styles', () {
+//     test('[Example 7.4]', () {
+//       expectYamlLoads({
+//         "implicit block key": [{"implicit flow key": "value"}]
+//       }, """
+// "implicit block key" : [
+//   "implicit flow key" : value,
+//  ]
+// """);
+//     });
+
+//     test('[Example 7.5]', () {
+//       expectYamlLoads(
+//         "folded to a space,\nto a line feed, or \t \tnon-content", """
+// "folded 
+// to a space,\t
+ 
+// to a line feed, or \t\\
+//  \\ \tnon-content"
+// """);
+//     });
+
+//     test('[Example 7.6]', () {
+//       expectYamlLoads(" 1st non-empty\n2nd non-empty 3rd non-empty ", """
+// " 1st non-empty
+
+//  2nd non-empty 
+// \t3rd non-empty "
+// """);
+//     });
+
+//     test('[Example 7.7]', () {
+//       expectYamlLoads("here's to \"quotes\"", "'here''s to \"quotes\"'");
+//     });
+
+//     test('[Example 7.8]', () {
+//       expectYamlLoads({
+//         "implicit block key": [{"implicit flow key": "value"}]
+//       }, """
+// 'implicit block key' : [
+//   'implicit flow key' : value,
+//  ]
+// """);
+//     });
+
+//     test('[Example 7.9]', () {
+//       expectYamlLoads(" 1st non-empty\n2nd non-empty 3rd non-empty ", """
+// ' 1st non-empty
+
+//  2nd non-empty 
+// \t3rd non-empty '
+// """);
+//     });
+
+//     test('[Example 7.10]', () {
+//       expectYamlLoads([
+//         "::vector", ": - ()", "Up, up, and away!", -123,
+//         "http://example.com/foo#bar",
+//         [
+//           "::vector", ": - ()", "Up, up, and away!", -123,
+//           "http://example.com/foo#bar"
+//         ]
+//       ], """
+// # Outside flow collection:
+// - ::vector
+// - ": - ()"
+// - Up, up, and away!
+// - -123
+// - http://example.com/foo#bar
+// # Inside flow collection:
+// - [ ::vector,
+//   ": - ()",
+//   "Up, up and away!",
+//   -123,
+//   http://example.com/foo#bar ]
+// """);
+//     });
+
+//     test('[Example 7.11]', () {
+//       expectYamlLoads({
+//         "implicit block key": [{"implicit flow key": "value"}]
+//       }, """
+// implicit block key : [
+//   implicit flow key : value,
+//  ]
+// """);
+//     });
+
+//     test('[Example 7.12]', () {
+//       expectYamlLoads("1st non-empty\n2nd non-empty 3rd non-empty", """
+// 1st non-empty
+
+//  2nd non-empty 
+// \t3rd non-empty
+// """);
+//     });
+  });
+
+  group('7.4: Flow Collection Styles', () {
+//     test('[Example 7.13]', () {
+//       expectYamlLoads([
+//         ['one', 'two'],
+//         ['three', 'four']
+//       ], """
+// - [ one, two, ]
+// - [three ,four]
+// """);
+//     });
+
+//     test('[Example 7.14]', () {
+//       expectYamlLoads([
+//         "double quoted", "single quoted", "plain text", ["nested"],
+//         {"single": "pair"}
+//       ], """
+// [
+// "double
+//  quoted", 'single
+//            quoted',
+// plain
+//  text, [ nested ],
+// single: pair,
+// ]
+// """);
+//     });
+
+//     test('[Example 7.15]', () {
+//       expectYamlLoads([
+//         {"one": "two", "three": "four"},
+//         {"five": "six", "seven": "eight"},
+//       ], """
+// - { one : two , three: four , }
+// - {five: six,seven : eight}
+// """);
+//     });
+
+//     test('[Example 7.16]', () {
+//       var doc = yamlMap({
+//         "explicit": "entry",
+//         "implicit": "entry"
+//       });
+//       doc[null] = null;
+//       expectYamlLoads(doc, """
+// {
+// ? explicit: entry,
+// implicit: entry,
+// ?
+// }
+// """);
+//     });
+
+//     test('[Example 7.17]', () {
+//       var doc = yamlMap({
+//         "unquoted": "separate",
+//         "http://foo.com": null,
+//         "omitted value": null
+//       });
+//       doc[null] = "omitted key";
+//       expectYamlLoads(doc, """
+// {
+// unquoted : "separate",
+// http://foo.com,
+// omitted value:,
+// : omitted key,
+// }
+// """);
+//     });
+
+//     test('[Example 7.18]', () {
+//       expectYamlLoads({
+//         "adjacent": "value",
+//         "readable": "value",
+//         "empty": null
+//       }, """
+// {
+// "adjacent":value,
+// "readable": value,
+// "empty":
+// }
+// """);
+//     });
+
+//     test('[Example 7.19]', () {
+//       expectYamlLoads([{"foo": "bar"}], """
+// [
+// foo: bar
+// ]
+// """);
+//     });
+
+//     test('[Example 7.20]', () {
+//       expectYamlLoads([{"foo bar": "baz"}], """
+// [
+// ? foo
+//  bar : baz
+// ]
+// """);
+//     });
+
+//     test('[Example 7.21]', () {
+//       var el1 = yamlMap();
+//       el1[null] = "empty key array";
+
+//       var el2 = yamlMap();
+//       el2[{"JSON": "like"}] = "adjacent";
+//       expectYamlLoads([[{"YAML": "separate"}], [el1], [el2]], """
+// - [ YAML : separate ]
+// - [ : empty key entry ]
+// - [ {JSON: like}:adjacent ]
+// """);
+//     });
+
+//     test('[Example 7.22]', () {
+//       Expect.throws(() => yaml.load("""
+// [ foo
+//  bar: invalid ]
+// """));
+
+//       var dotList = [];
+//       dotList.insertRange(0, 1024, ' ');
+//       var dots = Strings.join(dotList, '');
+//       Expect.throws(() => yaml.load('[ "foo...$dots...bar": invalid ]'));
+//     });
+  });
+
+  group('7.5: Flow Nodes', () {
+//     test('[Example 7.23]', () {
+//       expectYamlLoads([["a", "b"], {"a": "b"}, "a", "b", "c"], """
+// - [ a, b ]
+// - { a: b }
+// - "a"
+// - 'b'
+// - c
+// """);
+//     });
+
+//     test('[Example 7.24]', () {
+//       expectYamlLoads(["a", "b", "c", "c", ""], """
+// - !!str "a"
+// - 'b'
+// - &anchor "c"
+// - *anchor
+// - !!str
+// """);
+//     });
+  });
+
+  // Chapter 8: Block Styles
+  group('8.1: Block Scalar Styles', () {
+//     test('[Example 8.1]', () {
+//       expectYamlLoads(["literal\n", " folded\n", "keep\n\n", " strip"], """
+// - | # Empty header
+//  literal
+// - >1 # Indentation indicator
+//   folded
+// - |+ # Chomping indicator
+//  keep
+
+// - >1- # Both indicators
+//   strip
+// """);
+//     });
+
+//     test('[Example 8.2]', () {
+//       expectYamlLoads([
+//         "detected\n",
+//         "\n\n# detected\n",
+//         " explicit\n",
+//         "\t detected\n"
+//       ], """
+// - |
+//  detected
+// - >
+ 
+  
+//   # detected
+// - |1
+//   explicit
+// - >
+//  \t
+//  detected
+// """);
+//     });
+
+//     test('[Example 8.3]', () {
+//       Expect.throws(() => yaml.load("""
+// - |
+  
+//  text
+// """));
+
+//       Expect.throws(() => yaml.load("""
+// - >
+//   text
+//  text
+// """));
+
+//       Expect.throws(() => yaml.load("""
+// - |2
+//  text
+// """));
+//     });
+
+//     test('[Example 8.4]', () {
+//       expectYamlLoads({"strip": "text", "clip": "text\n", "keep": "text\n"}, """
+// strip: |-
+//   text
+// clip: |
+//   text
+// keep: |+
+//   text
+// """);
+//     });
+
+//     test('[Example 8.5]', () {
+//       expectYamlLoads({
+//         "strip": "# text",
+//         "clip": "# text\n",
+//         "keep": "# text\n"
+//       }, """
+//  # Strip
+//   # Comments:
+// strip: |-
+//   # text
+  
+//  # Clip
+//   # comments:
+
+// clip: |
+//   # text
+ 
+//  # Keep
+//   # comments:
+
+// keep: |+
+//   # text
+
+//  # Trail
+//   # comments.
+// """);
+//     });
+
+//     test('[Example 8.6]', () {
+//       expectYamlLoads({"strip": "", "clip": "", "keep": "\n"}, """
+// strip: >-
+
+// clip: >
+
+// keep: |+
+
+// """);
+//     });
+
+//     test('[Example 8.7]', () {
+//       expectYamlLoads("literal\n\ttext\n", """
+// |
+//  literal
+//  \ttext
+
+// """);
+//     });
+
+//     test('[Example 8.8]', () {
+//       expectYamlLoads("\n\nliteral\n \n\ntext\n", """
+// |
+ 
+  
+//   literal
+   
+  
+//   text
+
+//  # Comment
+// """);
+//     });
+
+//     test('[Example 8.9]', () {
+//       expectYamlLoads("folded text\n", """
+// >
+//  folded
+//  text
+
+// """);
+//     });
+
+//     test('[Example 8.10]', () {
+//       expectYamlLoads("""
+// folded line
+// next line
+//   * bullet
+
+//   * list
+//   * lines
+
+// last line
+// """, """
+// >
+
+//  folded
+//  line
+
+//  next
+//  line
+//    * bullet
+
+//    * list
+//    * lines
+
+//  last
+//  line
+
+// # Comment
+// """);
+//     });
+
+    // Examples 8.11 through 8.13 are duplicates of 8.10.
+  });
+
+  group('8.2: Block Collection Styles', () {
+    test('[Example 8.14]', () {
+      expectYamlLoads({"block sequence": ["one", {"two": "three"}]}, """
+block sequence:
+  - one
+  - two : three
+""");
+    });
+
+//     test('[Example 8.15]', () {
+//       expectYamlLoads([
+//         null, "block node\n", ["one", "two"], [{"one": "two"}]
+//       ], """
+// - # Empty
+// - |
+//  block node
+// - - one # Compact
+//   - two # sequence
+// - one: two # Compact mapping
+// """);
+//     });
+
+    test('[Example 8.16]', () {
+      expectYamlLoads({"block mapping": {"key": "value"}}, """
+block mapping:
+ key: value
+""");
+    });
+
+//     test('[Example 8.17]', () {
+//       expectYamlLoads({
+//         "explicit key": null,
+//         "block key\n": ["one", "two"]
+//       }, """
+// ? explicit key # Empty value
+// ? |
+//   block key
+// : - one # Explicit compact
+//   - two # block value
+// """);
+//     });
+
+//     test('[Example 8.18]', () {
+//       var doc = yamlMap({
+//         'plain key': 'in-line value',
+//         "quoted key": ["entry"]
+//       });
+//       doc[null] = null;
+//       expectYamlLoads(doc, """
+// plain key: in-line value
+// : # Both empty
+// "quoted key":
+// - entry
+// """);
+//     });
+
+//     test('[Example 8.19]', () {
+//       var el = yamlMap();
+//       el[{'earth': 'blue'}] = {'moon': 'white'};
+//       expectYamlLoads([{'sun': 'yellow'}, el], """
+// - sun: yellow
+// - ? earth: blue
+//   : moon: white
+// """);
+//     });
+
+//     test('[Example 8.20]', () {
+//       expectYamlLoads(["flow in block", "Block scalar\n", {"foo": "bar"}], """
+// -
+//   "flow in block"
+// - >
+//  Block scalar
+// - !!map # Block collection
+//   foo : bar
+// """);
+//     });
+
+//     test('[Example 8.21]', () {
+//       expectYamlLoads({"literal": "value", "folded": "value"}, """
+// literal: |2
+//   value
+// folded:
+//    !!str
+//   >1
+//  value
+// """);
+//     });
+
+//     test('[Example 8.22]', () {
+//       expectYamlLoads({
+//         "sequence": ["entry", ["nested"]],
+//         "mapping": {"foo": "bar"}
+//       }, """
+// sequence: !!seq
+// - entry
+// - !!seq
+//  - nested
+// mapping: !!map
+//  foo: bar
+// """);
+//     });
+  });
+
+  // Chapter 9: YAML Character Stream
+  group('9.1: Documents', () {
+    // Example 9.1 tests the use of a BOM, which this implementation currently
+    // doesn't plan to support.
+
+//     test('[Example 9.2]', () {
+//       expectYamlLoads("Document", """
+// %YAML 1.2
+// ---
+// Document
+// ... # Suffix
+// """);
+//     });
+
+//     test('[Example 9.3]', () {
+//       expectYamlStreamLoads(["Bare Document", "%!PS-Adobe-2.0\n"], """
+// Bare
+// document
+// ...
+// # No document
+// ...
+// |
+// %!PS-Adobe-2.0 # Not the first line
+// """);
+//     });
+
+//     test('[Example 9.4]', () {
+//       expectYamlStreamLoads([{"matches %": 20}, null], """
+// ---
+// { matches
+// % : 20 }
+// ...
+// ---
+// # Empty
+// ...
+// """);
+//     });
+
+//     test('[Example 9.5]', () {
+//       expectYamlStreamLoads(["%!PS-Adobe-2.0\n", null], """
+// %YAML 1.2
+// --- |
+// %!PS-Adobe-2.0
+// ...
+// %YAML1.2
+// ---
+// # Empty
+// ...
+// """);
+//     });
+
+//     test('[Example 9.6]', () {
+//       expectYamlStreamLoads(["Document", null, {"matches %": 20}], """
+// Document
+// ---
+// # Empty
+// ...
+// %YAML 1.2
+// ---
+// matches %: 20
+// """);
+//     });
+  });
+
+  // Chapter 10: Recommended Schemas
+  group('10.1: Failsafe Schema', () {
+//     test('[Example 10.1]', () {
+//       expectYamlStreamLoads({
+//         "Block style": {
+//           "Clark": "Evans",
+//           "Ingy": "döt Net",
+//           "Oren": "Ben-Kiki"
+//         },
+//         "Flow style": {
+//           "Clark": "Evans",
+//           "Ingy": "döt Net",
+//           "Oren": "Ben-Kiki"
+//         }
+//       }, """
+// Block style: !!map
+//   Clark : Evans
+//   Ingy  : döt Net
+//   Oren  : Ben-Kiki
+
+// Flow style: !!map { Clark: Evans, Ingy: döt Net, Oren: Ben-Kiki }
+// """);
+//     });
+
+//     test('[Example 10.2]', () {
+//       expectYamlStreamLoads({
+//         "Block style": ["Clark Evans", "Ingy döt Net", "Oren Ben-Kiki"],
+//         "Flow style": ["Clark Evans", "Ingy döt Net", "Oren Ben-Kiki"]
+//       }, """
+// Block style: !!seq
+// - Clark Evans
+// - Ingy döt Net
+// - Oren Ben-Kiki
+
+// Flow style: !!seq [ Clark Evans, Ingy döt Net, Oren Ben-Kiki ]
+// """);
+//     });
+
+//     test('[Example 10.3]', () {
+//       expectYamlStreamLoads({
+//         "Block style": "String: just a theory.",
+//         "Flow style": "String: just a theory."
+//       }, """
+// Block style: !!str |-
+//   String: just a theory.
+
+// Flow style: !!str "String: just a theory."
+// """);
+//     });
+  });
+
+  group('10.2: JSON Schema', () {
+//     test('[Example 10.4]', () {
+//       var doc = yamlMap({"key with null value": null});
+//       doc[null] = "value for null key";
+//       expectYamlStreamLoads(doc, """
+// !!null null: value for null key
+// key with null value: !!null null
+// """);
+//     });
+
+//     test('[Example 10.5]', () {
+//       expectYamlStreamLoads({
+//         "YAML is a superset of JSON": true,
+//         "Pluto is a planet": false
+//       }, """
+// YAML is a superset of JSON: !!bool true
+// Pluto is a planet: !!bool false
+// """);
+//     });
+
+//     test('[Example 10.6]', () {
+//       expectYamlStreamLoads({
+//         "negative": -12,
+//         "zero": 0,
+//         "positive": 34
+//       }, """
+// negative: !!int -12
+// zero: !!int 0
+// positive: !!int 34
+// """);
+//     });
+
+//     test('[Example 10.7]', () {
+//       expectYamlStreamLoads({
+//         "negative": -1,
+//         "zero": 0,
+//         "positive": 23000,
+//         "infinity": infinity,
+//         "not a number": nan
+//       }, """
+// negative: !!float -1
+// zero: !!float 0
+// positive: !!float 2.3e4
+// infinity: !!float .inf
+// not a number: !!float .nan
+// """);
+//     });
+
+//     test('[Example 10.8]', () {
+//       expectYamlStreamLoads({
+//         "A null": null,
+//         "Booleans": [true, false],
+//         "Integers": [0, -0, 3, -19],
+//         "Floats": [0, 0, 12000, -200000],
+//         // Despite being invalid in the JSON schema, these values are valid in
+//         // the core schema which this implementation supports.
+//         "Invalid": [ true, null, 7, 0x3A, 12.3]
+//       }, """
+// A null: null
+// Booleans: [ true, false ]
+// Integers: [ 0, -0, 3, -19 ]
+// Floats: [ 0., -0.0, 12e03, -2E+05 ]
+// Invalid: [ True, Null, 0o7, 0x3A, +12.3 ]
+// """);
+//     });
+  });
+
+  group('10.3: Core Schema', () {
+//     test('[Example 10.9]', () {
+//       expectYamlStreamLoads({
+//         "A null": null,
+//         "Also a null": null,
+//         "Not a null": "",
+//         "Booleans": [true, true, false, false],
+//         "Integers": [0, 7, 0x3A, -19],
+//         "Floats": [0, 0, 0.5, 12000, -200000],
+//         "Also floats": [infinity, -infinity, infinity, nan]
+//       }, """
+// A null: null
+// Also a null: # Empty
+// Not a null: ""
+// Booleans: [ true, True, false, FALSE ]
+// Integers: [ 0, 0o7, 0x3A, -19 ]
+// Floats: [ 0., -0.0, .5, +12e03, -2E+05 ]
+// Also floats: [ .inf, -.Inf, +.INF, .NAN ]
+// """);
+//     });
+  });
+}