Bring the YAML package's style up to modern standards.

pkg/yaml/test/yaml_test.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;
+library yaml.test;
 
 // TODO(rnystrom): rewrite tests so that they don't need "Expect".
-import "package:expect/expect.dart";
 import 'package:unittest/unittest.dart';
 import 'package:yaml/yaml.dart';
-import 'package:yaml/src/deep_equals.dart';
-// TODO(jmesserly): we should not be reaching outside the YAML package
-// The http package has a similar problem.
-import '../../../tests/utils/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>)');
-}
+import 'utils.dart';

[Bob Nystrom, 2014/05/09 00:18:56]

Is this a new file? I don't see it in the patch.

[nweiz, 2014/05/20 00:15:07]

Oops, added.

 
 main() {
   var infinity = double.parse("Infinity");
   var nan = double.parse("NaN");
 
   group('YamlMap', () {
     group('accepts as a key', () {
       _expectKeyWorks(keyFn()) {
         var map = yamlMap();
         map[keyFn()] = 5;
@@ skipping 448 matching lines @@
     }
 
     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'));
+      expectYamlFails('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));
@@ skipping 77 matching lines @@
     });
 
     // 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"));
+      expectYamlFails("commercial-at: @text");
+      expectYamlFails("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('form feed', () => expectYamlFails("- 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')));
@@ skipping 38 matching lines @@
         "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-"'));
+      expectYamlFails('Bad escape: "\\c"');
+      expectYamlFails('Bad escape: "\\xq-"');
     });
   });
 
   // Chapter 6: Basic Structures
   group('6.1: Indentation Spaces', () {
     test('may not include TAB characters', () {
-      Expect.throws(() => loadYaml(cleanUpLiteral(
+      expectYamlFails(
         """
         -
         \t- foo
-        \t- bar""")));
+        \t- bar""");
     });
 
     test('must be the same for all sibling nodes', () {
-      Expect.throws(() => loadYaml(cleanUpLiteral(
+      expectYamlFails(
         """
         -
           - foo
-         - bar""")));
+         - bar""");
     });
 
     test('may be different for the children of sibling nodes', () {
       expectYamlLoads([["foo"], ["bar"]],
         """
         -
           - foo
         -
          - bar""");
     });
@@ skipping 206 matching lines @@
         - | # comment
             # not comment
             foo
         """);
       });
     });
   });
 
   group('6.7: Separation Lines', () {
     test('may not be used within implicit keys', () {
-      Expect.throws(() => loadYaml(cleanUpLiteral(
+      expectYamlFails(
         """
         [1,
-         2]: 3""")));
+         2]: 3""");
     });
 
     test('[Example 6.12]', () {
       var doc = yamlMap();
       doc[{'first': 'Sammy', 'last': 'Sosa'}] = {
         'hr': 65,
         'avg': 0.278
       };
       expectYamlLoads(doc,
         """
@@ skipping 20 matching lines @@
     // test('[Example 6.14]', () {
     //   expectYamlLoads("foo",
     //     '''
     //     %YAML 1.3 # Attempt parsing
     //                # with a warning
     //     ---
     //     "foo"''');
     // });
 
     // test('[Example 6.15]', () {
-    //   Expect.throws(() => loadYaml(cleanUpLiteral(
+    //   expectYamlFails(
     //     """
     //     %YAML 1.2
     //     %YAML 1.1
-    //     foo""")));
+    //     foo""");
     // });
 
     // test('[Example 6.16]', () {
     //   expectYamlLoads("foo",
     //     '''
     //     %TAG !yaml! tag:yaml.org,2002:
     //     ---
     //     !yaml!str "foo"''');
     // });
 
     // test('[Example 6.17]', () {
-    //   Expect.throws(() => loadYaml(cleanUpLiteral(
+    //   ExpectYamlFails(
     //     """
     //     %TAG ! !foo
     //     %TAG ! !foo
-    //     bar""")));
+    //     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"));
+    //   expectYamlFails("- !<!> foo");
+    //   expectYamlFails("- !<\$:?> 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(
+    //   expectYamlFails(
     //     """
     //     - *anchor
-    //     - &anchor foo"""));
+    //     - &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(
+    //   test('tag properties', () => expectYamlFails(
     //     """
     //     - &anchor foo
-    //     - !str *anchor""")));
+    //     - !str *anchor""");
 
-    //   test('anchor properties', () => Expect.throws(
-    //           () => loadYaml(cleanUpLiteral(
+    //   test('anchor properties', () => expectYamlFails(
     //     """
     //     - &anchor foo
-    //     - &anchor2 *anchor""")));
+    //     - &anchor2 *anchor""");
 
-    //   test('content', () => Expect.throws(() => loadYaml(cleanUpLiteral(
+    //   test('content', () => expectYamlFails(
     //     """
     //     - &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);
+    //   expect(anchorList, same(aliasList));
 
     //   doc = loadYaml(cleanUpLiteral(
     //     """
     //     ? &anchor [a, b, c]
     //     : ? *anchor
     //       : bar""");
     //   anchorList = doc.keys[0];
     //   aliasList = doc[['a', 'b', 'c']].keys[0];
-    //   Expect.isTrue(anchorList === aliasList);
-    //   anchorList.add('d');
-    //   Expect.listEquals(['a', 'b', 'c', 'd'], aliasList);
+    //   expect(anchorList, same(aliasList));
     // });
 
     // test('[Example 7.1]', () {
     //   expectYamlLoads({
     //     "First occurence": "Foo",
     //     "Second occurence": "Foo",
     //     "Override anchor": "Bar",
     //     "Reuse anchor": "Bar",
     //   },
     //     """
@@ skipping 235 matching lines @@
       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(
+      expectYamlFails(
         """
         [ foo
-         bar: invalid ]""")));
+         bar: invalid ]""");
 
       // TODO(nweiz): enable this when we throw an error for long keys
       // var dotList = new List.filled(1024, ' ');
       // var dots = dotList.join();
-      // Expect.throws(() => loadYaml('[ "foo...$dots...bar": invalid ]'));
+      // expectYamlFails('[ "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"
@@ skipping 48 matching lines @@
           # detected
         - |1
           explicit
         - >
          \t
          detected
         """);
     });
 
     test('[Example 8.3]', () {
-      Expect.throws(() => loadYaml(cleanUpLiteral(
+      expectYamlFails(
         """
         - |
           
-         text""")));
+         text""");
 
-      Expect.throws(() => loadYaml(cleanUpLiteral(
+      expectYamlFails(
         """
         - >
           text
-         text""")));
+         text""");
 
-      Expect.throws(() => loadYaml(cleanUpLiteral(
+      expectYamlFails(
         """
         - |2
-         text""")));
+         text""");
     });
 
     test('[Example 8.4]', () {
       expectYamlLoads({"strip": "text", "clip": "text\n", "keep": "text\n"},
         """
         strip: |-
           text
         clip: |
           text
         keep: |+
@@ skipping 421 matching lines @@
         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 ]''');
     });
   });
 }