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('yaml_test');
+
+#import('../../../lib/unittest/unittest.dart');
+#import('../../../utils/yaml/yaml.dart');
+#import('../../../utils/yaml/deep_equals.dart');
+#import('test_utils.dart');
+
+/** Constructs a new yaml.YamlMap, optionally from a normal Map. */
+Map yamlMap([Map from]) =>
+    from == null ? new YamlMap() : new YamlMap.from(from);
+
+/**
+ * Asserts that a string containing a single YAML document produces a given
+ * value when loaded.
+ */
+expectYamlLoads(expected, String source) {
+  var actual = loadYaml(cleanUpLiteral(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 = loadYamlStream(cleanUpLiteral(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(
+    //     cleanUpLiteral(
+    //     """
+    //       \//||\\/||
+    //       // ||  ||__"""),
+    //     """
+    //     # 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
+    //     cleanUpLiteral(
+    //     """
+    //     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(() => loadYaml('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(() => loadYaml("commercial-at: @text"));
+    //   Expect.throws(() => loadYaml("commercial-at: `text"));
+    // });
+  });
+
+  group('5.4: Line Break Characters', () {
+    group('include', () {
+      test('\\n', () => expectYamlLoads([1, 2], indentLiteral("- 1\n- 2")));
+      test('\\r', () => expectYamlLoads([1, 2], "- 1\r- 2"));
+    });
+
+    group('do not include', () {
+      test('form feed', () => Expect.throws(() => loadYaml("- 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", indentLiteral('- |\n  foo\r  bar')));
+    //   test("from \\r\\n to \\n", () =>
+    //         expectYamlLoads("foo\nbar", indentLiteral('- |\n  foo\r\n  bar')));
+    // });
+
+    // test('[Example 5.11]', () {
+    //   expectYamlLoads
+    //     cleanUpLiteral("""
+    //     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
+    //     expectYamlLoads("""
+    //     Fun with \x5C
+    //     \x22 \x07 \x08 \x1B \x0C
+    //     \x0A \x0D \x09 \x0B \x00
+    //     \x20 \xA0 \x85 \u2028 \u2029
+    //     A A A"""),
+    //     '''
+    //     "Fun with \\\\
+    //     \\" \\a \\b \\e \\f \\
+    //     \\n \\r \\t \\v \\0 \\
+    //     \\  \\_ \\N \\L \\P \\
+    //     \\x41 \\u0041 \\U00000041"''');
+    // });
+
+    // test('[Example 5.14]', () {
+    //   Expect.throws(() => loadYaml('Bad escape: "\\c"'));
+    //   Expect.throws(() => loadYaml('Bad escape: "\\xq-"'));
+    // });
+  });
+
+  // Chapter 6: Basic Structures
+  group('6.1: Indentation Spaces', () {
+    test('may not include TAB characters', () {
+      Expect.throws(() => loadYaml(cleanUpLiteral(
+        """
+        -
+        \t- foo
+        \t- bar""")));
+    });
+
+    test('must be the same for all sibling nodes', () {
+      Expect.throws(() => loadYaml(cleanUpLiteral(
+        """
+        -
+          - 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""");
+    // });
+
+    // 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(() => loadYaml(cleanUpLiteral(
+    //     """
+    //     [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(() => loadYaml(cleanUpLiteral(
+    //     """
+    //     %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(() => loadYaml(cleanUpLiteral(
+    //     """
+    //     %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(() => loadYaml("- !<!> foo"));
+    //   Expect.throws(() => loadYaml("- !<\$:?> 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(() => loadYaml(cleanUpLiteral(
+    //     """
+    //     - *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(() => loadYaml(cleanUpLiteral(
+    //     """
+    //     - &anchor foo
+    //     - !str *anchor""")));
+
+    //   test('anchor properties', () => Expect.throws(
+    //           () => loadYaml(cleanUpLiteral(
+    //     """
+    //     - &anchor foo
+    //     - &anchor2 *anchor""")));
+
+    //   test('content', () => Expect.throws(() => loadYaml(cleanUpLiteral(
+    //     """
+    //     - &anchor foo
+    //     - *anchor bar""")));
+    // });
+
+    // test('must preserve structural equality', () {
+    //   var doc = loadYaml(cleanUpLiteral(
+    //     """
+    //     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 = loadYaml(cleanUpLiteral(
+    //     """
+    //     ? &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(() => loadYaml(cleanUpLiteral(
+    //     """
+    //     [ foo
+    //      bar: invalid ]"""));
+
+    //   var dotList = [];
+    //   dotList.insertRange(0, 1024, ' ');
+    //   var dots = Strings.join(dotList, '');
+    //   Expect.throws(() => loadYaml('[ "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(() => loadYaml(cleanUpLiteral(
+    //     """
+    //     - |
+          
+    //      text""")));
+
+    //   Expect.throws(() => loadYaml(cleanUpLiteral(
+    //     """
+    //     - >
+    //       text
+    //      text""")));
+
+    //   Expect.throws(() => loadYaml(cleanUpLiteral(
+    //     """
+    //     - |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(
+    //     cleanUpLiteral("""
+    //     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 ]''');
+    // });
+  });
+}