Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(900)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: tests/utils/src/YamlTest.dart

Issue 10153004: Add a basic YAML processor. Much of the language is still unimplemented. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: More code review changes. Created 8 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « tests/utils/src/MarkdownTest.dart ('k') | tests/utils/src/test_utils.dart » ('j') | tools/test.dart » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: tests/utils/src/YamlTest.dart
diff --git a/tests/utils/src/YamlTest.dart b/tests/utils/src/YamlTest.dart
new file mode 100644
index 0000000000000000000000000000000000000000..e53b70639613236d13fab67c3f75000c75e7c7a1
--- /dev/null
+++ b/tests/utils/src/YamlTest.dart
@@ -0,0 +1,1826 @@
+// 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 ]''');
+ // });
+ });
+}
« no previous file with comments | « tests/utils/src/MarkdownTest.dart ('k') | tests/utils/src/test_utils.dart » ('j') | tools/test.dart » ('J')

Powered by Google App Engine
This is Rietveld 408576698