pkg/docgen: update markdown to 0.5.1

third_party/pkg/markdown/test/markdown_test.dart

 // Copyright (c) 2011, 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.
 
 /// Unit tests for markdown.
 library markdownTests;
 
 import 'package:unittest/unittest.dart';
-
-// TODO(rnystrom): Use "package:" URL (#4968).
-import '../lib/markdown.dart';
+import 'package:markdown/markdown.dart';
 
 /// Most of these tests are based on observing how showdown behaves:
 /// http://softwaremaniacs.org/playground/showdown-highlight/
 void main() {
   group('Paragraphs', () {
     validate('consecutive lines form a single paragraph', '''
         This is the first line.
         This is the second line.
         ''', '''
         <p>This is the first line.
@@ skipping 410 matching lines @@
         ''', '''
         <pre><code>code
         </code></pre>
         ''');
 
     validate('with an optional language identifier', '''
         ```dart
         code
         ```
         ''', '''
-        <pre><code>code
+        <pre class="dart"><code>code
         </code></pre>
         ''');
 
     validate('escape HTML characters', '''
         ```
         <&>
         ```
         ''', '''
         <pre><code>&lt;&amp;&gt;
         </code></pre>
         ''');
+
+    validate('Pandoc style without language identifier', '''
+        ~~~~~
+        code
+        ~~~~~
+        ''', '''
+        <pre><code>code
+        </code></pre>
+        ''');
+
+    validate('Pandoc style with language identifier', '''
+        ~~~~~dart
+        code
+        ~~~~~
+        ''', '''
+        <pre class="dart"><code>code
+        </code></pre>
+        ''');
+
+    validate('Pandoc style with inner tildes row', '''
+        ~~~~~
+        ~~~
+        code
+        ~~~
+        ~~~~~
+        ''', '''
+        <pre><code>~~~
+        code
+        ~~~
+        </code></pre>
+        ''');
   });
 
   group('Horizontal rules', () {
     validate('from dashes', '''
         ---
         ''', '''
         <hr />
         ''');
 
     validate('from asterisks', '''
@@ skipping 389 matching lines @@
 
     validate('dart custom links', 'links [are<foo>] awesome',
       '<p>links <a>are&lt;foo></a> awesome</p>',
       linkResolver: (text) => new Element.text('a', text.replaceAll('<',
       '&lt;')));
 
     // TODO(amouravski): need more tests here for custom syntaxes, as some
     // things are not quite working properly. The regexps are sometime a little
     // too greedy, I think.
   });
+
+  group('Inline only', () {
+    validate('simple line', '''
+        This would normally create a paragraph.
+        ''', '''
+        This would normally create a paragraph.
+        ''', inlineOnly: true);
+    validate('strong and em', '''
+        This would _normally_ create a **paragraph**.
+        ''', '''
+        This would <em>normally</em> create a <strong>paragraph</strong>.
+        ''', inlineOnly: true);
+    validate('link', '''
+        This [link](http://www.example.com/) will work normally.
+        ''', '''
+        This <a href="http://www.example.com/">link</a> will work normally.
+        ''', inlineOnly: true);
+    validate('references do not work', '''
+        [This][] shouldn't work, though.
+        ''', '''
+        [This][] shouldn't work, though.
+        ''', inlineOnly: true);
+    validate('less than and ampersand are escaped', '''
+        < &
+        ''', '''
+        &lt; &amp;
+        ''', inlineOnly: true);
+    validate('keeps newlines', '''
+        This paragraph
+        continues after a newline.
+        ''', '''
+        This paragraph
+        continues after a newline.
+        ''', inlineOnly: true);
+    validate('ignores block-level markdown syntax', '''
+        1. This will not be an <ol>.
+        ''', '''
+        1. This will not be an &lt;ol>.
+        ''', inlineOnly: true);
+  });
 }
 
 /**
  * Removes eight spaces of leading indentation from a multiline string.
  *
  * Note that this is very sensitive to how the literals are styled. They should
  * be:
  *     '''
  *     Text starts on own line. Lines up with subsequent lines.
  *     Lines are indented exactly 8 characters from the left margin.'''
@@ skipping 10 matching lines @@
     if (lines[j].length > 8) {
       lines[j] = lines[j].substring(8, lines[j].length);
     } else {
       lines[j] = '';
     }
   }
 
   return lines.join('\n');
 }
 
-validate(String description, String markdown, String html,
-         {bool verbose: false, inlineSyntaxes, linkResolver}) {
+void validate(String description, String markdown, String html,
+         {bool verbose: false, inlineSyntaxes, linkResolver,
+          bool inlineOnly: false}) {
   test(description, () {
     markdown = cleanUpLiteral(markdown);
     html = cleanUpLiteral(html);
 
     var result = markdownToHtml(markdown, inlineSyntaxes: inlineSyntaxes,
-        linkResolver: linkResolver);
+        linkResolver: linkResolver, inlineOnly: inlineOnly);
     var passed = compareOutput(html, result);
 
     if (!passed) {
       // Remove trailing newline.
       html = html.substring(0, html.length - 1);
 
-      print('FAIL: $description');
-      print('  expect: ${html.replaceAll("\n", "\n          ")}');
-      print('  actual: ${result.replaceAll("\n", "\n          ")}');
-      print('');
+      var sb = new StringBuffer();
+      sb.writeln('Expected: ${html.replaceAll("\n", "\n          ")}');
+      sb.writeln('  Actual: ${result.replaceAll("\n", "\n          ")}');
+
+      fail(sb.toString());
     }
-
-    expect(passed, isTrue, verbose: verbose);
   });
 }
 
 /// Does a loose comparison of the two strings of HTML. Ignores differences in
 /// newlines and indentation.
-compareOutput(String a, String b) {
+bool compareOutput(String a, String b) {
   int i = 0;
   int j = 0;
 
   skipIgnored(String s, int i) {
     // Ignore newlines.
     while ((i < s.length) && (s[i] == '\n')) {
       i++;
       // Ignore indentation.
       while ((i < s.length) && (s[i] == ' ')) i++;
     }
 
     return i;
   }
 
   while (true) {
     i = skipIgnored(a, i);
     j = skipIgnored(b, j);
 
     // If one string runs out of non-ignored strings, the other must too.
     if (i == a.length) return j == b.length;
     if (j == b.length) return i == a.length;
 
     if (a[i] != b[j]) return false;
     i++;
     j++;
   }
 }